Difference between revisions of "Lazarus IDE Tools/de"

From Lazarus wiki
Jump to navigationJump to search
m (checked, updated and translated --> finished)
m (→‎Code-Schablonen: findet sich unter Werkzeuge -> Vorlagen)
 
(11 intermediate revisions by 8 users not shown)
Line 9: Line 9:
 
{|
 
{|
 
|-
 
|-
| [[Lazarus_IDE_Tools/de#Find Declaration|Declaration Jumping]] || {{keypress|Strg}} + Klick (springt zur Deklaration eines Typs oder einer Variablen)
+
| [[Lazarus_IDE_Tools/de#Find Declaration|Declaration Jumping]] || {{keypress|Strg}}+Klick (springt zur Deklaration eines Typs oder einer Variablen)
 
|-
 
|-
| [[Lazarus_IDE_Tools/de#Method Jumping|Method Jumping]] || {{keypress|Strg}} + {{keypress|Shift}} + {{keypress|Up}} (schaltet zwischen Definition und Rumpf einer Prozedur/Methode um)
+
| [[Lazarus_IDE_Tools/de#Methodenspringen|Methodenspringen]] || {{keypress|Strg}}+{{keypress|Shift}}+{{keypress|Up}} (schaltet zwischen Definition und Rumpf einer Prozedur/Methode um)
 
|-
 
|-
| [[Lazarus_IDE_Tools/de#Code-Schablonen|Code-Schablonen]] || {{keypress|Strg}} + {{keypress|J}}
+
| [[Lazarus_IDE_Tools/de#Code-Schablonen|Code-Schablonen]] || {{keypress|Strg}}+{{keypress|J}}
 
|-
 
|-
 
| [[Lazarus_IDE_Tools/de#Synchronbearbeitung|Synchronbearbeitung]] || {{keypress|Strg}}+{{keypress|J}} (bei ausgewähltem Text)
 
| [[Lazarus_IDE_Tools/de#Synchronbearbeitung|Synchronbearbeitung]] || {{keypress|Strg}}+{{keypress|J}} (bei ausgewähltem Text)
 
|-
 
|-
| [[Lazarus_IDE_Tools/de#Code Completion|Quelltextvervollständigung]] (Class Completion) || {{keypress|Strg}} + {{keypress|Shift}} + {{keypress|C}}
+
| [[Lazarus_IDE_Tools/de#Codevervollständigung|Codevervollständigung]] (Klassenvervollständigung) || {{keypress|Strg}}+{{keypress|Shift}}+{{keypress|C}}
 
|-
 
|-
| [[Lazarus_IDE_Tools/de#Identifier Completion|Bezeichnervervollständigung]] || {{keypress|Strg}} + {{keypress|Space}}
+
| [[Lazarus_IDE_Tools/de#Bezeichner-Vervollständigung|Bezeichner-Vervollständigung]] || {{keypress|Strg}}+{{keypress|Space}}
 
|-
 
|-
| [[Lazarus_IDE_Tools/de#Word Completion|Wortvervollständigung]] || {{keypress|Strg}} + {{keypress|W}}
+
| [[Lazarus_IDE_Tools/de#Wortvervollständigung|Wortvervollständigung]] || {{keypress|Strg}}+{{keypress|W}}
 
|-
 
|-
| [[Lazarus_IDE_Tools/de#Parameter-Hinweise|Parameter-Hinweise]] || {{keypress|Strg}} + {{keypress|Shift}} + {{keypress|Space}}
+
| [[Lazarus_IDE_Tools/de#Parameter-Hinweise|Parameter-Hinweise]] || {{keypress|Strg}}+{{keypress|Shift}}+{{keypress|Space}}
 
|-
 
|-
| [[Lazarus_IDE_Tools/de#Inkrementelle Suche|Inkrementelle Suche]] || {{keypress|Strg}} + {{keypress|E}}
+
| [[Lazarus_IDE_Tools/de#Inkrementelle Suche|Inkrementelle Suche]] || {{keypress|Strg}}+{{keypress|E}}
 
|-
 
|-
| [[Lazarus_IDE_Tools/de#Rename Identifier|Bezeichner umbenennen]] || {{keypress|Strg}}+{{keypress|Shift}}+{{keypress|E}}
+
| [[Lazarus_IDE_Tools/de#Bezeichner umbenennen|Bezeichner umbenennen]] || {{keypress|Strg}}+{{keypress|Shift}}+{{keypress|E}}
 
|}
 
|}
  
== Method Jumping ==
+
==Methodenspringen==
 
Um zwischen einem Prozedurrumpf (begin..end) und der Prozedurdefinition (procedure Name;) zu springen, verwenden Sie {{keypress|Strg}}+{{keypress|Shift}}+{{keypress|Nach oben}}.
 
Um zwischen einem Prozedurrumpf (begin..end) und der Prozedurdefinition (procedure Name;) zu springen, verwenden Sie {{keypress|Strg}}+{{keypress|Shift}}+{{keypress|Nach oben}}.
  
 
Zum Beispiel:
 
Zum Beispiel:
interface
+
<syntaxhighlight lang=pascal>interface
+
 
procedure DoSomething; // Prozedurdefinition
+
procedure DoSomething; // Prozedurdefinition
 
+
 
implementation
+
implementation
 
+
 
procedure DoSomething; // Prozedurrumpf  
+
procedure DoSomething; // Prozedurrumpf  
begin
+
begin
end;
+
end;</syntaxhighlight>
 +
 
 
Wenn der Cursor auf dem Prozedurrumpf ist und Sie {{keypress|Strg}}+{{keypress|Shift}}+{{keypress|Nach oben}} drücken, dann wird der Kursor zur Definition springen. Erneutes Drücken von {{keypress|Strg}}+{{keypress|Shift}}+{{keypress|Nach oben}} wird wieder zum Rumpf springen, nach 'begin'.
 
Wenn der Cursor auf dem Prozedurrumpf ist und Sie {{keypress|Strg}}+{{keypress|Shift}}+{{keypress|Nach oben}} drücken, dann wird der Kursor zur Definition springen. Erneutes Drücken von {{keypress|Strg}}+{{keypress|Shift}}+{{keypress|Nach oben}} wird wieder zum Rumpf springen, nach 'begin'.
  
Line 48: Line 49:
  
 
Hinweise:
 
Hinweise:
'Method Jumping' springt zur selben Prozedur mit dem selben Namen und Parameterliste. Wenn es keine bestimmte Prozedur gibt, springt es zum besten Kandidaten und positioniert den Kursor auf dem ersten Unterschied. (Für Delphianer: Delphi kann dies nicht tun).
+
Methodenspringen springt zur selben Prozedur mit dem selben Namen und Parameterliste. Wenn es keine bestimmte Prozedur gibt, springt es zum besten Kandidaten und positioniert den Kursor auf dem ersten Unterschied. (Für Delphianer: Delphi kann dies nicht tun).
  
 
Zum Beispiel eine Prozedur mit verschiedenen Parametertypen:
 
Zum Beispiel eine Prozedur mit verschiedenen Parametertypen:
interface
+
<syntaxhighlight lang=pascal>interface
+
 
procedure DoSomething(p: char); // Prozedurdefinition
+
procedure DoSomething(p: char); // Prozedurdefinition
+
 
implementation
+
implementation
 
+
 
procedure DoSomething(p: string); // Prozedurrumpf
+
procedure DoSomething(p: string); // Prozedurrumpf
begin
+
begin
end;
+
end;</syntaxhighlight>
 +
 
 
Das Springen von der Definition zum Rumpf wird den Kursor auf dem 'string' Schlüsselwort positionieren. Dies kann verwendet werden für das Umbenennen von Methoden und/oder das Ändern von Parametern.  
 
Das Springen von der Definition zum Rumpf wird den Kursor auf dem 'string' Schlüsselwort positionieren. Dies kann verwendet werden für das Umbenennen von Methoden und/oder das Ändern von Parametern.  
  
 
Zum Beispiel:<br>
 
Zum Beispiel:<br>
 
Sie benannten 'DoSomething' in 'MakeIt' um:  
 
Sie benannten 'DoSomething' in 'MakeIt' um:  
interface
+
<syntaxhighlight lang=pascal>interface
+
 
procedure MakeIt; // Prozedurdefinition
+
procedure MakeIt; // Prozedurdefinition
+
 
implementation
+
implementation
+
 
procedure DoSomething; // Prozedurrumpf
+
procedure DoSomething; // Prozedurrumpf
begin
+
begin
end;
+
end;</syntaxhighlight>
 +
 
 
Dann springen Sie von MakeIt zum Rumpf. Die IDE sucht nach einem passenden Rumpf, findet keinen, und sucht daher nach einem Kandidaten. Weil Sie nur eine Prozedur umbenannt haben, gibt es exakt einen Rumpf ohne Definition (DoSomething) und daher wird sie zu DoSomething springen und den Kursor rechts neben 'DoSomething' positionieren. Dann können Sie sie dort auch umbenennen. Das funktioniert ebenfalls für Parameter.
 
Dann springen Sie von MakeIt zum Rumpf. Die IDE sucht nach einem passenden Rumpf, findet keinen, und sucht daher nach einem Kandidaten. Weil Sie nur eine Prozedur umbenannt haben, gibt es exakt einen Rumpf ohne Definition (DoSomething) und daher wird sie zu DoSomething springen und den Kursor rechts neben 'DoSomething' positionieren. Dann können Sie sie dort auch umbenennen. Das funktioniert ebenfalls für Parameter.
  
Line 80: Line 83:
 
Im Gegensatz zu Delphi bietet die Lazarus IDE volle Unterstützung für Include-Dateien. Sie können zum Beispiel von der Methode in der .pas Datei zum Methodenrumpf in der Include-Datei springen. Alle CodeTools wie ''Codevervollständigung'' berücksichtigen Include-Dateien als spezielle Schranken.
 
Im Gegensatz zu Delphi bietet die Lazarus IDE volle Unterstützung für Include-Dateien. Sie können zum Beispiel von der Methode in der .pas Datei zum Methodenrumpf in der Include-Datei springen. Alle CodeTools wie ''Codevervollständigung'' berücksichtigen Include-Dateien als spezielle Schranken.
 
   
 
   
Zum Beispiel: Wenn ''Codevervollständigung'' einen neuen Methodenrumpf hinzufügt hinter anderen Methodenrümpfen, behält es beide in der selben Datei. Auf diese Weise können Sie ganze Klassenimplementierungen in Include-Dateien verwenden, wie es die LCL für nahezu alle Bedienelemente tut.
+
Zum Beispiel: Wenn die ''Codevervollständigung'' einen neuen Methodenrumpf hinzufügt hinter anderen Methodenrümpfen, behält sie beide in der selben Datei. Auf diese Weise können Sie ganze Klassenimplementierungen in Include-Dateien verwenden, wie es die LCL für nahezu alle Bedienelemente tut.
  
 
Aber es gibt eine Anfängerfalle:
 
Aber es gibt eine Anfängerfalle:
Line 87: Line 90:
 
Sobald die IDE die Unit analysiert, wird sie die Include-Direktive dort finden und die IDE wird sich an diese Beziehung erinnern. Sie wird diese Informationen beim Beenden (oder beim Speichern des Projekts) speichern in der Datei ~/.lazarus/includelinks.xml. Wenn Sie diese Include-Datei das nächste Mal öffnen und eine 'find declaration' durchführen, wird die IDE die Unit intern öffnen und das Springen wird funktionieren.
 
Sobald die IDE die Unit analysiert, wird sie die Include-Direktive dort finden und die IDE wird sich an diese Beziehung erinnern. Sie wird diese Informationen beim Beenden (oder beim Speichern des Projekts) speichern in der Datei ~/.lazarus/includelinks.xml. Wenn Sie diese Include-Datei das nächste Mal öffnen und eine 'find declaration' durchführen, wird die IDE die Unit intern öffnen und das Springen wird funktionieren.
 
Sie können die IDE auch direkt hinweisen mit  
 
Sie können die IDE auch direkt hinweisen mit  
{%mainunit yourunit.pas}  
+
<syntaxhighlight lang=pascal>{%mainunit yourunit.pas}</syntaxhighlight>
 
am Anfang Ihrer yourinclude.inc.
 
am Anfang Ihrer yourinclude.inc.
  
Line 97: Line 100:
 
Code-Schablonen konvertieren einen Bezeichner in einen Text oder Code-Fragment.
 
Code-Schablonen konvertieren einen Bezeichner in einen Text oder Code-Fragment.
  
Die Code-Schablonen Vorgabetastenkombination ist {{keypress|Strg}}+{{keypress|J}}. Sie können einen Bezeichner eintippen, {{keypress|Strg}}+{{keypress|J}} drücken und der Bezeichner wird durch den Text ersetzt, der für den Bezeichner definiert ist. Code-Schablonen können definiert werden in Einstellungen -> Code-Schablonen.
+
Die Code-Schablonen Vorgabetastenkombination ist {{keypress|Strg}}+{{keypress|J}}. Sie können einen Bezeichner eintippen, {{keypress|Strg}}+{{keypress|J}} drücken und der Bezeichner wird durch den Text ersetzt, der für den Bezeichner definiert ist. Code-Schablonen können definiert werden in Werkzeuge -> Vorlagen.
  
 
Beispiel:
 
Beispiel:
 
Schreiben Sie den Bezeichner 'classf', lassen Sie den Kursor hinter dem 'f' stehen und drücken Sie {{keypress|Strg}}+{{keypress|J}}. Das 'classf' wird ersetzt durch
 
Schreiben Sie den Bezeichner 'classf', lassen Sie den Kursor hinter dem 'f' stehen und drücken Sie {{keypress|Strg}}+{{keypress|J}}. Das 'classf' wird ersetzt durch
T = class(T)
+
<syntaxhighlight lang=pascal>T = class(T)
private
+
private
+
 
public
+
public
  constructor Create;
+
  constructor Create;
  destructor Destroy; override;
+
  destructor Destroy; override;
end;
+
end;</syntaxhighlight>
 +
 
 
und der Cursor ist hinter dem 'T'.
 
und der Cursor ist hinter dem 'T'.
 
Sie können die Liste der Vorlagen abrufen, in dem Sie den Kursor an eine freie Stelle positionieren (nicht auf einem Bezeichner) und {{keypress|Strg}}+{{keypress|J}} drücken. Die Liste der Code-Schablonen wird auftauchen. Verwenden Sie die Kursortasten oder tippen Sie einige Buchstaben um eine auszuwählen. {{keypress|Eingabe}} erzeugt die gewählte Vorlage und {{keypress|Escape}}schließt das Popup-Fenster.
 
Sie können die Liste der Vorlagen abrufen, in dem Sie den Kursor an eine freie Stelle positionieren (nicht auf einem Bezeichner) und {{keypress|Strg}}+{{keypress|J}} drücken. Die Liste der Code-Schablonen wird auftauchen. Verwenden Sie die Kursortasten oder tippen Sie einige Buchstaben um eine auszuwählen. {{keypress|Eingabe}} erzeugt die gewählte Vorlage und {{keypress|Escape}}schließt das Popup-Fenster.
Line 119: Line 123:
 
Zum Beispiel
 
Zum Beispiel
  
  Canvas.FillRect(|);
+
<syntaxhighlight lang=pascal>  Canvas.FillRect(|);</syntaxhighlight>
  
 
Platzieren Sie den Cursor in den Klammern und drücken Sie {{keypress|Strg}}+{{keypress|Shift}}+{{keypress|Leertaste}}. Eine Hinweisbox erscheint mit den Parametern von FillRect.
 
Platzieren Sie den Cursor in den Klammern und drücken Sie {{keypress|Strg}}+{{keypress|Shift}}+{{keypress|Leertaste}}. Eine Hinweisbox erscheint mit den Parametern von FillRect.
Line 135: Line 139:
 
== Inkrementelle Suche ==
 
== Inkrementelle Suche ==
  
Die inkrementelle Suche ändert die Statuszeile des Quelltexteditors. Geben Sie ein paar Zeichen ein und der Editor sucht und markiert sofort alle Fundstellen im Text. Das Tastaturkürzel ist {{keypress|Strg}}+{{keypress|e}}.
+
Die inkrementelle Suche ändert die Statuszeile des Quelltexteditors. Geben Sie ein paar Zeichen ein und der Editor sucht und markiert sofort alle Fundstellen im Text. Das Tastaturkürzel ist {{keypress|Strg}}+{{keypress|E}}.
*Zum Beispiel: Sie drücken {{keypress|e}}, sucht und markiert alle Fundstellen von 'e'.
+
*Zum Beispiel: Sie drücken {{keypress|A}}, sucht und markiert alle Fundstellen von 'A'.
*Dann drücken Sie {{keypress|t}} und alle Fundstellen von 'et' sind markiert usw.
+
*Dann drücken Sie {{keypress|T}} und alle Fundstellen von 'at' sind markiert usw.
*Sie springen zur nächsten Fundstelle mit {{keypress|F3}} (oder {{keypress|Strg}}+{{keypress|e}} während der Suche) und zur vorigen Fundstelle mit {keypress|Umschalt}}+{{keypress|F3}}.
+
*Sie springen zur nächsten Fundstelle mit {{keypress|F3}} (oder {{keypress|Strg}}+{{keypress|E}} während der Suche) und zur vorigen Fundstelle mit {{keypress|Umschalt}}+{{keypress|F3}}.
 
*{{keypress|Backspace}} entfernt das letzte Zeichen
 
*{{keypress|Backspace}} entfernt das letzte Zeichen
 
*{{keypress|Eingabe}} stoppt die Suche ohne eine neue Zeile im Editor.
 
*{{keypress|Eingabe}} stoppt die Suche ohne eine neue Zeile im Editor.
*Sie nehmen die letzte Suche erneut auf mit einem zweiten {{keypress|Strg}}+{{keypress|e}}, sofort nach dem Start der Suche mit {{keypress|Strg}}+{{keypress|e}}. Das gilt solange das Suchfeld noch leer ist.
+
*Sie nehmen die letzte Suche erneut auf mit einem zweiten {{keypress|Strg}}+{{keypress|E}}, sofort nach dem Start der Suche mit {{keypress|Strg}}+{{keypress|E}}. Das gilt solange das Suchfeld noch leer ist.
 
*Einfügen mit {{keypress|Strg}}+{{keypress|V}} hängt den Text aus der Zwischenablage an den aktuellen Suchtext an (seit Lazarus 0.9.27 r19824).
 
*Einfügen mit {{keypress|Strg}}+{{keypress|V}} hängt den Text aus der Zwischenablage an den aktuellen Suchtext an (seit Lazarus 0.9.27 r19824).
  
Line 148: Line 152:
 
*Stellen Sie den Textkursor auf den Bezeichner. (Wählen Sie nichts aus!)
 
*Stellen Sie den Textkursor auf den Bezeichner. (Wählen Sie nichts aus!)
 
*Drücken Sie {{keypress|Strg}}+{{keypress|C}}. Der Editor wählt den Bezeichner aus und kopiert ihn in die Zwischenablage
 
*Drücken Sie {{keypress|Strg}}+{{keypress|C}}. Der Editor wählt den Bezeichner aus und kopiert ihn in die Zwischenablage
*Drücken Sie{{keypress|Strg}}+{{keypress|E}} - startet die inkrementelle Suche
+
*Drücken Sie {{keypress|Strg}}+{{keypress|E}} - startet die inkrementelle Suche
*Drücken Sie{{keypress|Strg}}+{{keypress|V}} - sucht nach dem Bezeichner (seit Version 0.9.27)
+
*Drücken Sie {{keypress|Strg}}+{{keypress|V}} - sucht nach dem Bezeichner (seit Version 0.9.27)
 
*Mit {{keypress|F3}} und {{keypress|Umschalt}}+{{keypress|F3}} springen Sie zum nächsten/vorigen Fund.
 
*Mit {{keypress|F3}} und {{keypress|Umschalt}}+{{keypress|F3}} springen Sie zum nächsten/vorigen Fund.
 
*Mit einer beliebigen Taste (beispielsweise Kursor links oder rechts) beenden Sie die Suche
 
*Mit einer beliebigen Taste (beispielsweise Kursor links oder rechts) beenden Sie die Suche
Line 202: Line 206:
 
Zum Beispiel: Erzeugen Sie eine Klasse (siehe Code-Schablonen, um einige Tipparbeit zu sparen):  
 
Zum Beispiel: Erzeugen Sie eine Klasse (siehe Code-Schablonen, um einige Tipparbeit zu sparen):  
  
TExample = class(TObject)
+
<syntaxhighlight lang=pascal>TExample = class(TObject)
public
+
public
  constructor Create;
+
  constructor Create;
  destructor Destroy; override;
+
  destructor Destroy; override;
end;
+
end;</syntaxhighlight>
 +
 
 
Positionieren Sie den Kursor irgendwo in der Klasse und drücken Sie {{keypress|Strg|Shift|C}}. Dies wird die fehlenden Methodenrümpfe erzeugen und den Kursor zu dem ersten erzeugten Methodenrumpf bewegen, so dass Sie jetzt mit dem Schreiben des Klassencodes beginnen können:  
 
Positionieren Sie den Kursor irgendwo in der Klasse und drücken Sie {{keypress|Strg|Shift|C}}. Dies wird die fehlenden Methodenrümpfe erzeugen und den Kursor zu dem ersten erzeugten Methodenrumpf bewegen, so dass Sie jetzt mit dem Schreiben des Klassencodes beginnen können:  
  
{ TExample }
+
<syntaxhighlight lang=pascal>{ TExample }
+
 
constructor TExample.Create;
+
constructor TExample.Create;
begin
+
begin
  |
+
  |
end;
+
end;
+
 
destructor TExample.Destroy;
+
destructor TExample.Destroy;
begin
+
begin
  inherited Destroy;
+
  inherited Destroy;
end;
+
end;</syntaxhighlight>
 +
 
 
Anmerkung: Das '|' ist der Kursor und nicht hinzugefügt.  
 
Anmerkung: Das '|' ist der Kursor und nicht hinzugefügt.  
  
Line 228: Line 234:
 
Jetzt fügen Sie eine Methode DoSomething hinzu:  
 
Jetzt fügen Sie eine Methode DoSomething hinzu:  
  
TExample = class(TObject)
+
<syntaxhighlight lang=pascal>TExample = class(TObject)
public
+
public
  constructor Create;
+
  constructor Create;
  procedure DoSomething(i: integer);
+
  procedure DoSomething(i: integer);
  destructor Destroy; override;
+
  destructor Destroy; override;
end;
+
end;</syntaxhighlight>
  
 
Dann drücken Sie {{keypress|Strg|Shift|C}} und die IDE wird hinzufügen:  
 
Dann drücken Sie {{keypress|Strg|Shift|C}} und die IDE wird hinzufügen:  
  
procedure TExample.DoSomething(i: integer);
+
<syntaxhighlight lang=pascal>procedure TExample.DoSomething(i: integer);
begin
+
begin
  |
+
  |
end;
+
end;</syntaxhighlight>
Sie sehen, der neue Methodenrumpf wurde zwischen Create und Destroy eingefügt, exakt wie in der KLassendefinition. So behalten auch die Methodenrümpfe die gleiche logische Ordnung bei (wie von Ihnen festgelegt). Sie legen die Einfügerichtlinien fest in Einstellungen -> Codetools Einstellungen -> Quelltexterzeugung.  
+
 
 +
Sie sehen, der neue Methodenrumpf wurde zwischen Create und Destroy eingefügt, exakt wie in der Klassendefinition. So behalten auch die Methodenrümpfe die gleiche logische Ordnung bei (wie von Ihnen festgelegt). Sie legen die Einfügerichtlinien fest in Einstellungen -> Codetools Einstellungen -> Quelltexterzeugung.  
  
 
'''Complete Properties'''<br>
 
'''Complete Properties'''<br>
 
Fügen Sie eine Eigenschaft 'AnInteger' hinzu:
 
Fügen Sie eine Eigenschaft 'AnInteger' hinzu:
TExample = class(TObject)
+
<syntaxhighlight lang=pascal>TExample = class(TObject)
public
+
public
  constructor Create;
+
  constructor Create;
  procedure DoSomething(i: integer);
+
  procedure DoSomething(i: integer);
  destructor Destroy; override;
+
  destructor Destroy; override;
  property AnInteger: Integer;
+
  property AnInteger: Integer;
end;
+
end;</syntaxhighlight>
Drücken Sie Strg+Shift+C und Sie erhalten:
+
 
procedure TExample.SetAnInteger(const AValue: integer);
+
Drücken Sie {{keypress|Ctrl|Shift|C}} und Sie erhalten:
begin
+
<syntaxhighlight lang=pascal>procedure TExample.SetAnInteger(const AValue: integer);
  |if FAnInteger=AValue then exit;
+
begin
  FAnInteger:=AValue;
+
  |if FAnInteger=AValue then exit;
end;
+
  FAnInteger:=AValue;
 +
end;</syntaxhighlight>
 +
 
 
Die Codevervollständigung hat den Schreibzugriff geändert und den üblichen Code ergänzt.
 
Die Codevervollständigung hat den Schreibzugriff geändert und den üblichen Code ergänzt.
 
Springen Sie mit {{keypress|Strg|Shift|Nach oben}} zur Klasse, um die neue Klasse ganz zu sehen:
 
Springen Sie mit {{keypress|Strg|Shift|Nach oben}} zur Klasse, um die neue Klasse ganz zu sehen:
TExample = class(TObject)
+
<syntaxhighlight lang=pascal>TExample = class(TObject)
private
+
private
  FAnInteger: integer;
+
  FAnInteger: integer;
  procedure SetAnInteger(const AValue: integer);
+
  procedure SetAnInteger(const AValue: integer);
public
+
public
  constructor Create;
+
  constructor Create;
  procedure DoSomething(i: integer);
+
  procedure DoSomething(i: integer);
  destructor Destroy; override;
+
  destructor Destroy; override;
  property AnInteger: integer read FAnInteger write SetAnInteger;
+
  property AnInteger: integer read FAnInteger write SetAnInteger;
end;
+
end;</syntaxhighlight>
 +
 
 
Die Eigenschaft wurde um einen Lese- und Schreibzugriff erweitert. Die Klasse erhielt den neuen Abschnitt 'private' mit einer Variable 'FAnInteger' und der Methode 'SetAnInteger'.
 
Die Eigenschaft wurde um einen Lese- und Schreibzugriff erweitert. Die Klasse erhielt den neuen Abschnitt 'private' mit einer Variable 'FAnInteger' und der Methode 'SetAnInteger'.
 
Es ist eine allgemein übliche Delphi-Stil-Regel, den privaten Variablen ein 'F' und der write-Methode ein 'Set' voranzustellen. Wenn Sie das nicht mögen, können Sie es ändern unter Einstellungen -> Codetools Einstellungen -> Quelltexterzeugung.
 
Es ist eine allgemein übliche Delphi-Stil-Regel, den privaten Variablen ein 'F' und der write-Methode ein 'Set' voranzustellen. Wenn Sie das nicht mögen, können Sie es ändern unter Einstellungen -> Codetools Einstellungen -> Quelltexterzeugung.
  
 
Erzeugen einer Eigenschaft 'read only':
 
Erzeugen einer Eigenschaft 'read only':
property PropName: PropType read;
+
<syntaxhighlight lang=pascal>property PropName: PropType read;</syntaxhighlight>
 
wird erweitert zu
 
wird erweitert zu
property PropName: PropType read FPropName;
+
<syntaxhighlight lang=pascal>property PropName: PropType read FPropName;</syntaxhighlight>
 
Erzeugen einer Eigenschaft 'write only':
 
Erzeugen einer Eigenschaft 'write only':
  property PropName: PropType write;
+
<syntaxhighlight lang=pascal>property PropName: PropType write;</syntaxhighlight>
 
wird erweitert zu
 
wird erweitert zu
property PropName: PropType write SetPropName;
+
<syntaxhighlight lang=pascal>property PropName: PropType write SetPropName;</syntaxhighlight>
 
Erzeugen einer Eigenschaft 'read only' mit einer Read-Methode:
 
Erzeugen einer Eigenschaft 'read only' mit einer Read-Methode:
property PropName: PropType read GetPropName;
+
<syntaxhighlight lang=pascal>property PropName: PropType read GetPropName;</syntaxhighlight>
 
wird beibehalten und eine Funktion 'GetPropName' wird angefügt:
 
wird beibehalten und eine Funktion 'GetPropName' wird angefügt:
function GetpropName: PropType;
+
<syntaxhighlight lang=pascal>function GetpropName: PropType;</syntaxhighlight>
 
Erzeugen einer Eigenschaft mit einem stored-Modifizierer:
 
Erzeugen einer Eigenschaft mit einem stored-Modifizierer:
property PropName: PropType stored;
+
<syntaxhighlight lang=pascal>property PropName: PropType stored;</syntaxhighlight>
 
wird erweitert zu
 
wird erweitert zu
property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;
+
<syntaxhighlight lang=pascal>property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;</syntaxhighlight>
 
Weil 'stored' für das Streaming benutzt wird, werden automatisch auch die read- und write-Modifizierer angefügt.
 
Weil 'stored' für das Streaming benutzt wird, werden automatisch auch die read- und write-Modifizierer angefügt.
  
 
Hinweis:
 
Hinweis:
 
Die ''Bezeichnervervollständigung'' erkennt auch unvollständige Eigenschaften und wird die Standardnamen vorschlagen. Zum Beispiel:
 
Die ''Bezeichnervervollständigung'' erkennt auch unvollständige Eigenschaften und wird die Standardnamen vorschlagen. Zum Beispiel:
property PropName: PropType read |;
+
<syntaxhighlight lang=pascal>property PropName: PropType read |;</syntaxhighlight>
 
Platzieren Sie den Kursor eine Leerstelle hinter dem 'read'-Schlüsselwort und drücken Strg+Space für die Bezeichnervervollständigung. Diese wird Ihnen die Variable 'FPropName' und die Prozedur 'SetPropName' präsentieren.
 
Platzieren Sie den Kursor eine Leerstelle hinter dem 'read'-Schlüsselwort und drücken Strg+Space für die Bezeichnervervollständigung. Diese wird Ihnen die Variable 'FPropName' und die Prozedur 'SetPropName' präsentieren.
  
Line 301: Line 311:
 
Zum Beispiel:
 
Zum Beispiel:
 
Fügen Sie eine neue Prozedur zum Interface-Abschnitt hinzu:
 
Fügen Sie eine neue Prozedur zum Interface-Abschnitt hinzu:
procedure DoSomething;
+
<syntaxhighlight lang=pascal>procedure DoSomething;</syntaxhighlight>
 
Platzieren Sie den Kursor darauf und drücken Sie {{keypress|Strg|Shift|C}} für Codevervollständigung. Es wird im Implementation-Abschnitt erzeugen:
 
Platzieren Sie den Kursor darauf und drücken Sie {{keypress|Strg|Shift|C}} für Codevervollständigung. Es wird im Implementation-Abschnitt erzeugen:
procedure DoSomething;
+
<syntaxhighlight lang=pascal>procedure DoSomething;
begin
+
begin
  |
+
  |
end;
+
end;</syntaxhighlight>
 +
 
 
Hinweis: Sie können zwischen einer Prozedurdefinition und ihrem Rumpf springen mit {{keypress|Strg|Shift|Nach oben}}.
 
Hinweis: Sie können zwischen einer Prozedurdefinition und ihrem Rumpf springen mit {{keypress|Strg|Shift|Nach oben}}.
  
 
Der neue Prozedurrumpf wird vor den Klassenmethoden eingefügt. Wenn es bereits einige Prozeduren im Interface-Abschnitt gibt, versucht die IDE die Ordnung einzuhalten. Zum Beispiel:
 
Der neue Prozedurrumpf wird vor den Klassenmethoden eingefügt. Wenn es bereits einige Prozeduren im Interface-Abschnitt gibt, versucht die IDE die Ordnung einzuhalten. Zum Beispiel:
  procedure Proc1;
+
<syntaxhighlight lang=pascal>procedure Proc1;
  procedure Proc2; // neue Prozedur
+
procedure Proc2; // neue Prozedur
  procedure Proc3;
+
procedure Proc3;</syntaxhighlight>
 +
 
 
Wenn die Rümpfe von Proc1 und Proc3 bereits existieren, dann wird der Proc2 Rumpf zwischen den Rümpfen von Proc1 und Proc3 eingefügt. Dieses Verhalten kann eingestellt werden in Einstellungen -> CodeTools Einstellungen -> Quelltexterzeugung.
 
Wenn die Rümpfe von Proc1 und Proc3 bereits existieren, dann wird der Proc2 Rumpf zwischen den Rümpfen von Proc1 und Proc3 eingefügt. Dieses Verhalten kann eingestellt werden in Einstellungen -> CodeTools Einstellungen -> Quelltexterzeugung.
  
 
Mehrere Prozeduren:
 
Mehrere Prozeduren:
procedure Proc1_Old; // Rumpf existiert
+
<syntaxhighlight lang=pascal>procedure Proc1_Old; // Rumpf existiert
procedure Proc2_New; // Rumpf existiert nicht
+
procedure Proc2_New; // Rumpf existiert nicht
procedure Proc3_New; //  "
+
procedure Proc3_New; //  "
procedure Proc4_New; //  "
+
procedure Proc4_New; //  "
procedure Proc5_Old; // Rumpf existiert
+
procedure Proc5_Old; // Rumpf existiert</syntaxhighlight>
 +
 
 
Die Codevervollständigung wird alle 3 Prozedurrümpfe hinzufügen (Proc2_New, Proc3_New, Proc4_New).
 
Die Codevervollständigung wird alle 3 Prozedurrümpfe hinzufügen (Proc2_New, Proc3_New, Proc4_New).
  
 
Warum wird das ''Forward Procedure Completion'' genannt?
 
Warum wird das ''Forward Procedure Completion'' genannt?
  
Weil es nicht nur für Prozeduren funktioniert, die im Interface definiert sind, sondern auch für Prozeduren mit dem "forward"-Bezeichner. Und weil die CodeTools Prozeduren im Interfaceso behandeln als hätten sie einen impliziten "forward"-Bezeichner.
+
Weil es nicht nur für Prozeduren funktioniert, die im Interface definiert sind, sondern auch für Prozeduren mit dem "forward"-Bezeichner. Und weil die CodeTools Prozeduren im Interface so behandeln als hätten sie einen impliziten "forward"-Bezeichner.
  
 
===Event Assignment Completion===
 
===Event Assignment Completion===
Line 332: Line 345:
 
Zum Beispiel:
 
Zum Beispiel:
 
In einer Methode, sagen wir dem FormCreate Ereignis, fügen wir eine Zeile 'OnPaint:=' hinzu:
 
In einer Methode, sagen wir dem FormCreate Ereignis, fügen wir eine Zeile 'OnPaint:=' hinzu:
procedure TForm1.Form1Create(Sender: TObject);
+
<syntaxhighlight lang=pascal>procedure TForm1.Form1Create(Sender: TObject);
begin
+
begin
  OnPaint:=|
+
  OnPaint:=|
end;
+
end;</syntaxhighlight>
 +
 
 
Das '|' ist der Kursor und sollte nicht eingegeben werden.
 
Das '|' ist der Kursor und sollte nicht eingegeben werden.
 
Dann drücken sie Strg+Shift+C für die ''Codevervollständigung''. Die Anweisung wird komplettiert zu
 
Dann drücken sie Strg+Shift+C für die ''Codevervollständigung''. Die Anweisung wird komplettiert zu
OnPaint:=@Form1Paint;
+
<syntaxhighlight lang=pascal>OnPaint:=@Form1Paint;</syntaxhighlight>
 
Eine neue Methode Form1Paint wird zur Klasse TForm1 hinzugefügt. Dann wird die ''class completion'' gestartet und Sie erhalten:
 
Eine neue Methode Form1Paint wird zur Klasse TForm1 hinzugefügt. Dann wird die ''class completion'' gestartet und Sie erhalten:
procedure TForm1.Form1Paint(Sender: TObject);
+
<syntaxhighlight lang=pascal>procedure TForm1.Form1Paint(Sender: TObject);
begin
+
begin
  |
+
  |
end;
+
end;</syntaxhighlight>
 
Das funktioniert wie das Hinzufügen von Methoden im Objektinspektor.
 
Das funktioniert wie das Hinzufügen von Methoden im Objektinspektor.
  
Line 351: Line 365:
 
Hinweis:<br>
 
Hinweis:<br>
 
Sie können den neuen Methodennamen selbst definieren. Zum Beispiel:
 
Sie können den neuen Methodennamen selbst definieren. Zum Beispiel:
  OnPaint:=@ThePaintMethod;
+
<syntaxhighlight lang=pascal>OnPaint:=@ThePaintMethod;</syntaxhighlight>
  
 
===Variable Declaration Completion===
 
===Variable Declaration Completion===
Line 357: Line 371:
  
 
Zum Beispiel:
 
Zum Beispiel:
<delphi>
+
<syntaxhighlight lang=pascal>procedure TForm1.Form1Create(Sender: TObject);
procedure TForm1.Form1Create(Sender: TObject);
 
 
begin
 
begin
 
   i:=3;
 
   i:=3;
end;
+
end;</syntaxhighlight>
</delphi>
 
 
Platzieren Sie den Kursor auf dem 'i' oder genau dahinter. Dann drücken Sie {{keypress|Strg|Shift|C}} für die Codevervollständigung und Sie erhalten:
 
Platzieren Sie den Kursor auf dem 'i' oder genau dahinter. Dann drücken Sie {{keypress|Strg|Shift|C}} für die Codevervollständigung und Sie erhalten:
<delphi>
+
<syntaxhighlight lang=pascal>procedure TForm1.Form1Create(Sender: TObject);
procedure TForm1.Form1Create(Sender: TObject);
 
 
var
 
var
 
   i: Integer;
 
   i: Integer;
 
begin
 
begin
 
   i:=3;
 
   i:=3;
end;
+
end;</syntaxhighlight>
</delphi>
+
 
 
Die CodeTools prüfen zuerst, ob der Bezeichner 'i' bereits definiert ist und wenn nicht werden sie die Deklaration 'var i: integer;' hinzufügen. Der Typ des Bezeichners wird erraten vom Ausdruck rechts des ':=' Zuweisungsoperators. Zahlen wie die 3 sind mit Integer vorbelegt.
 
Die CodeTools prüfen zuerst, ob der Bezeichner 'i' bereits definiert ist und wenn nicht werden sie die Deklaration 'var i: integer;' hinzufügen. Der Typ des Bezeichners wird erraten vom Ausdruck rechts des ':=' Zuweisungsoperators. Zahlen wie die 3 sind mit Integer vorbelegt.
  
 
Ein anderes Beispiel:
 
Ein anderes Beispiel:
<delphi>
+
<syntaxhighlight lang=pascal>type
type
 
 
   TWhere = (Behind, Middle, InFront);
 
   TWhere = (Behind, Middle, InFront);
 
   
 
   
Line 384: Line 394:
 
   begin
 
   begin
 
     for Where:=Low(a) to High(a) do writeln(a[Where]);
 
     for Where:=Low(a) to High(a) do writeln(a[Where]);
   end;
+
   end;</syntaxhighlight>
</delphi>
+
 
 
Platzieren Sie den Kursor auf 'Where' und drücken Sie {{keypress|Strg|Shift|C}} für die Codevervollständigung. Sie erhalten:
 
Platzieren Sie den Kursor auf 'Where' und drücken Sie {{keypress|Strg|Shift|C}} für die Codevervollständigung. Sie erhalten:
<delphi>
+
<syntaxhighlight lang=pascal> procedure TForm1.Form1Create(Sender: TObject);
  procedure TForm1.Form1Create(Sender: TObject);
 
 
   var
 
   var
 
     a: array[TWhere] of char;
 
     a: array[TWhere] of char;
Line 394: Line 403:
 
   begin
 
   begin
 
     for Where:=Low(a) to High(a) do writeln(a[Where]);
 
     for Where:=Low(a) to High(a) do writeln(a[Where]);
   end;
+
   end;</syntaxhighlight>
</delphi>
 
  
 
Seit Version 0.9.11 komplettiert Lazarus auch Parameter. Zum Beispiel
 
Seit Version 0.9.11 komplettiert Lazarus auch Parameter. Zum Beispiel
<delphi>
+
<syntaxhighlight lang=pascal> procedure TForm1.FormPaint(Sender: TObject);
  procedure TForm1.FormPaint(Sender: TObject);
 
 
   begin
 
   begin
 
     with Canvas do begin
 
     with Canvas do begin
 
       Line(x1,y1,x2,y2);
 
       Line(x1,y1,x2,y2);
 
     end;
 
     end;
   end;
+
   end;</syntaxhighlight>
</delphi>
+
 
 
Platzieren Sie den Kursor auf 'x1' und drücken Sie {{keypress|Strg|Shift|C}} für die Codevervollständigung. Sie erhalten:
 
Platzieren Sie den Kursor auf 'x1' und drücken Sie {{keypress|Strg|Shift|C}} für die Codevervollständigung. Sie erhalten:
<delphi>
+
<syntaxhighlight lang=pascal> procedure TForm1.FormPaint(Sender: TObject);
  procedure TForm1.FormPaint(Sender: TObject);
 
 
   var
 
   var
 
     x1: integer;
 
     x1: integer;
Line 415: Line 421:
 
       Line(x1,y1,x2,y2);
 
       Line(x1,y1,x2,y2);
 
     end;
 
     end;
   end;
+
   end;</syntaxhighlight>
</delphi>
 
  
 
===Procedure Call Completion===
 
===Procedure Call Completion===
Line 422: Line 427:
  
 
Angenommen, Sie haben gerade die Anweisung "DoSomething(Width);" geschrieben
 
Angenommen, Sie haben gerade die Anweisung "DoSomething(Width);" geschrieben
<delphi>
+
<syntaxhighlight lang=pascal>procedure SomeProcedure;
procedure SomeProcedure;
 
 
var
 
var
 
   Width: integer;
 
   Width: integer;
Line 429: Line 433:
 
   Width:=3;
 
   Width:=3;
 
   DoSomething(Width);
 
   DoSomething(Width);
end;
+
end;</syntaxhighlight>
</delphi>
 
  
 
Platzieren Sie den Kursor über dem Bezeichner "DoSomething" und drücken Sie {{keypress|Strg|Shift|C}}. Sie erhalten:
 
Platzieren Sie den Kursor über dem Bezeichner "DoSomething" und drücken Sie {{keypress|Strg|Shift|C}}. Sie erhalten:
  
<delphi>
+
<syntaxhighlight lang=pascal>procedure DoSomething(aWidth: LongInt);
procedure DoSomething(aWidth: LongInt);
 
 
begin
 
begin
  
Line 446: Line 448:
 
   Width:=3;
 
   Width:=3;
 
   DoSomething(Width);
 
   DoSomething(Width);
end;
+
end;</syntaxhighlight>
</delphi>
 
  
 
Es werden derzeit noch keine Funktionen oder Methoden erzeugt.
 
Es werden derzeit noch keine Funktionen oder Methoden erzeugt.
  
=== Reversed Class Completion ===
+
===Reversed Class Completion===
  
 
"Reversed Class Completion" ist ein Teil der '''Codevervollständigung''' und fügt eine private Methodendeklaration zum aktuellen Methodenrumpf hinzu. Sie wird aufgerufen, wenn der Cursor in einem Methodenrumpf ist, der noch nicht in der Klasse definiert wurde.
 
"Reversed Class Completion" ist ein Teil der '''Codevervollständigung''' und fügt eine private Methodendeklaration zum aktuellen Methodenrumpf hinzu. Sie wird aufgerufen, wenn der Cursor in einem Methodenrumpf ist, der noch nicht in der Klasse definiert wurde.
Line 457: Line 458:
  
 
Zum Beispiel:
 
Zum Beispiel:
  procedure TForm1.DoSomething(Sender: TObject);
+
<syntaxhighlight lang=pascal>  procedure TForm1.DoSomething(Sender: TObject);
 
   begin
 
   begin
   end;
+
   end;</syntaxhighlight>
  
 
Die Methode DoSomething ist noch nicht in TForm1 deklariert. Drücken Sie {{keypress|Strg|Shift|C}} und die IDE wird "procedure DoSomething(Sender: TObject);" zu den privaten Methoden von TForm1 hinzufügen.
 
Die Methode DoSomething ist noch nicht in TForm1 deklariert. Drücken Sie {{keypress|Strg|Shift|C}} und die IDE wird "procedure DoSomething(Sender: TObject);" zu den privaten Methoden von TForm1 hinzufügen.
Line 466: Line 467:
 
Die Klassenergänzung arbeitet unter Lazarus immer in einer Richtung: Von dem Klasseninterface zur Implementation oder rückwärts/umgekehrt von der Klassenimplementation zum Interface. Delphi ruft immer beide Richtungen auf. Das Delphi-Verfahren hat den Nachteil, dass bei einem Rechtschreibfehler leicht eine neue Methodenvorlage erzeugt wird ohne Benachrichtigung.
 
Die Klassenergänzung arbeitet unter Lazarus immer in einer Richtung: Von dem Klasseninterface zur Implementation oder rückwärts/umgekehrt von der Klassenimplementation zum Interface. Delphi ruft immer beide Richtungen auf. Das Delphi-Verfahren hat den Nachteil, dass bei einem Rechtschreibfehler leicht eine neue Methodenvorlage erzeugt wird ohne Benachrichtigung.
  
=== Kommentare und Codevervollständigung ===
+
===Kommentare und Codevervollständigung===
 
Die Codevervollständigung versucht die Kommentare dort zu behalten, wo sie hingehören.  
 
Die Codevervollständigung versucht die Kommentare dort zu behalten, wo sie hingehören.  
 
Zum Beispiel:
 
Zum Beispiel:
  FList: TList; // list of TComponent
+
<syntaxhighlight lang=pascal>  FList: TList; // list of TComponent
   FInt: integer;
+
   FInt: integer;</syntaxhighlight>
 
Wenn eine neue Variable zwischen FList und FInt eingesetzt wird, dann wird der Kommentar in der FList Zeile beibehalten. Das selbe gilt für
 
Wenn eine neue Variable zwischen FList und FInt eingesetzt wird, dann wird der Kommentar in der FList Zeile beibehalten. Das selbe gilt für
  FList: TList; { list of TComponent
+
<syntaxhighlight lang=pascal>  FList: TList; { list of TComponent
 
     Dies ist ein Kommentar über mehrere Zeilen, beginnend
 
     Dies ist ein Kommentar über mehrere Zeilen, beginnend
 
     in der FList-Zeile. Die CodeTools nehmen an, er gehöre  
 
     in der FList-Zeile. Die CodeTools nehmen an, er gehöre  
 
     zu der FList-Zeile und brechen diese Beziehung nicht
 
     zu der FList-Zeile und brechen diese Beziehung nicht
 
     auf. Der Code wird hinter dem Kommentar eingefügt. }
 
     auf. Der Code wird hinter dem Kommentar eingefügt. }
   FInt: integer;
+
   FInt: integer;</syntaxhighlight>
 
Wenn der Kommentar in der nächsten Zeile startet, dann wird er behandelt, wie wenn er zum nachfolgenden Code gehört. Zum Beispiel:
 
Wenn der Kommentar in der nächsten Zeile startet, dann wird er behandelt, wie wenn er zum nachfolgenden Code gehört. Zum Beispiel:
  FList: TList; // list of TComponent
+
<syntaxhighlight lang=pascal>  FList: TList; // list of TComponent
 
     { Dieser Kommentar gehört zur nachfolgenden Anweisung.  
 
     { Dieser Kommentar gehört zur nachfolgenden Anweisung.  
 
       Neuer Code wird oberhalb des Kommentars eingefügt und  
 
       Neuer Code wird oberhalb des Kommentars eingefügt und  
 
       hinter dem Kommentar der FList-Zeile. }
 
       hinter dem Kommentar der FList-Zeile. }
   FInt: integer;
+
   FInt: integer;</syntaxhighlight>
  
 
===Method update===
 
===Method update===
 
Normalerweise fügt die Klassenergänzung alle fehlenden Methodenrümpfe ein. (Seit Version 0.9.27) Falls sich aber genau eine Methode zwischen Klassendeklaration und Rümpfen unterscheidet, dann wird der Methodenrumpf aktualisiert. Zum Beispiel: Sie haben eine Methode ''DoSomething''.
 
Normalerweise fügt die Klassenergänzung alle fehlenden Methodenrümpfe ein. (Seit Version 0.9.27) Falls sich aber genau eine Methode zwischen Klassendeklaration und Rümpfen unterscheidet, dann wird der Methodenrumpf aktualisiert. Zum Beispiel: Sie haben eine Methode ''DoSomething''.
<Delphi>
+
<syntaxhighlight lang=pascal> public
  public
 
 
     procedure DoSomething;
 
     procedure DoSomething;
 
   end;
 
   end;
Line 494: Line 494:
 
procedure TForm.DoSomething;
 
procedure TForm.DoSomething;
 
begin
 
begin
end;
+
end;</syntaxhighlight>
</Delphi>
 
  
 
Fügen Sie jetzt einen Parameter hinzu:
 
Fügen Sie jetzt einen Parameter hinzu:
  
<Delphi>
+
<syntaxhighlight lang=pascal> public
  public
 
 
     procedure DoSomething(i: integer);
 
     procedure DoSomething(i: integer);
   end;
+
   end;</syntaxhighlight>
</Delphi>
 
  
 
und rufen Sie die Codevervollständigung auf mit ({{keypress|Strg|Shift|C}}). Der Methodenrumpf wird aktualisiert und der neue Parameter wird kopiert:
 
und rufen Sie die Codevervollständigung auf mit ({{keypress|Strg|Shift|C}}). Der Methodenrumpf wird aktualisiert und der neue Parameter wird kopiert:
  
<Delphi>
+
<syntaxhighlight lang=pascal>procedure TForm.DoSomething(i: integer);
procedure TForm.DoSomething(i: integer);
 
 
begin
 
begin
end;
+
end;</syntaxhighlight>
</Delphi>
 
  
 
==Refactoring==
 
==Refactoring==
Line 517: Line 512:
 
===Invert Assignments===
 
===Invert Assignments===
  
;Kurz gefasst: : "Invert Assignments" nimmt einige ausgewählte Pascal-Anweisungen und invertiert alle Zuweisungen aus diesem Code. Dieses Werkzeug ist hilfreich für das Umwandeln eines "Speicher"-Codes in einen "Lade"-Code und umgekehrt.
+
;Kurz gefasst: "Invert Assignments" nimmt einige ausgewählte Pascal-Anweisungen und invertiert alle Zuweisungen aus diesem Code. Dieses Werkzeug ist hilfreich für das Umwandeln eines "Speicher"-Codes in einen "Lade"-Code und umgekehrt.
  
 
Beispiel:<br>
 
Beispiel:<br>
procedure DoSomething;
+
<syntaxhighlight lang=pascal>procedure DoSomething;
begin
+
begin
  AValueStudio:= BValueStudio;
+
  AValueStudio:= BValueStudio;
  AValueAppartment :=BValueAppartment;
+
  AValueAppartment :=BValueAppartment;
  AValueHouse:=BValueHouse;
+
  AValueHouse:=BValueHouse;
end;
+
end;</syntaxhighlight>
 +
 
 
Wählen Sie die Zeilen mit den Zuweisungen aus (zwischen begin und end) und führen Sie "Invert Assignments" aus. Alle Zuweisungen werden invertiert und die Einrückung wird automatisch hinzugefügt. Zum Beispiel:
 
Wählen Sie die Zeilen mit den Zuweisungen aus (zwischen begin und end) und führen Sie "Invert Assignments" aus. Alle Zuweisungen werden invertiert und die Einrückung wird automatisch hinzugefügt. Zum Beispiel:
  
 
Resultat:
 
Resultat:
procedure DoSomething;
+
<syntaxhighlight lang=pascal>procedure DoSomething;
begin
+
begin
  BValueStudio    := AValueStudio;
+
  BValueStudio    := AValueStudio;
  BValueAppartment := AValueAppartment;
+
  BValueAppartment := AValueAppartment;
  BValueHouse      := AValueHouse;
+
  BValueHouse      := AValueHouse;
end;
+
end;</syntaxhighlight>
  
 
=== Enclose Selection ===
 
=== Enclose Selection ===
 
Wählen Sie einigen Text aus und rufen Sie die Vervollständigung auf. In dem aufscheinenden Dialog können Sie auswählen, ob der selektierte Text in '''try..finally''' oder einen der vielen anderen üblichen Blöcke eingeschlossen werden soll.
 
Wählen Sie einigen Text aus und rufen Sie die Vervollständigung auf. In dem aufscheinenden Dialog können Sie auswählen, ob der selektierte Text in '''try..finally''' oder einen der vielen anderen üblichen Blöcke eingeschlossen werden soll.
  
=== Rename Identifier ===
+
===Bezeichner umbenennen===
 
Stellen Sie den Kursor auf einen Bezeichner und rufen Sie die Vervollständigung auf. Es erscheint ein Dialog, wo Sie den Suchbereich und den neuen Namen festlegen können.  
 
Stellen Sie den Kursor auf einen Bezeichner und rufen Sie die Vervollständigung auf. Es erscheint ein Dialog, wo Sie den Suchbereich und den neuen Namen festlegen können.  
 
* Es werden alle Vorkommen umbenannt und zwar nur jene, die tatsächlich diese Deklaration verwenden. Das bedeutet, dass nicht automatisch alle Deklarationen mit dem selben Namen umbenannt werden.  
 
* Es werden alle Vorkommen umbenannt und zwar nur jene, die tatsächlich diese Deklaration verwenden. Das bedeutet, dass nicht automatisch alle Deklarationen mit dem selben Namen umbenannt werden.  
Line 545: Line 541:
 
* Beschränkungen: Das funktioniert nur mit Pascal-Quellen, benennt keine Dateinamen um und bearbeitet weder lfm/lrs-Dateien noch lazdoc-Dateien.
 
* Beschränkungen: Das funktioniert nur mit Pascal-Quellen, benennt keine Dateinamen um und bearbeitet weder lfm/lrs-Dateien noch lazdoc-Dateien.
  
=== Find Identifier References ===
+
===Find Identifier References===
 
Stellen Sie den Kursor auf einen Bezeichner und rufen Sie die Vervollständigung auf. Es erscheint ein Dialog, wo Sie den Suchbereich festlegen können. Die IDE sucht dann nach allen Vorkommen und nur solchen, die tatsächlich diese Deklaration verwenden. Das bedeutet, dass nicht andere Deklarationen mit dem selben Namen angezeigt werden.
 
Stellen Sie den Kursor auf einen Bezeichner und rufen Sie die Vervollständigung auf. Es erscheint ein Dialog, wo Sie den Suchbereich festlegen können. Die IDE sucht dann nach allen Vorkommen und nur solchen, die tatsächlich diese Deklaration verwenden. Das bedeutet, dass nicht andere Deklarationen mit dem selben Namen angezeigt werden.
  
Line 569: Line 565:
 
Das selbe gilt für Typen wie TColor.
 
Das selbe gilt für Typen wie TColor.
 
Für den Compiler ist es einfach ein 'longint'. Aber in den Quellen ist es definiert als
 
Für den Compiler ist es einfach ein 'longint'. Aber in den Quellen ist es definiert als
TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;
+
<syntaxhighlight lang=pascal>TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;
TColor = TGraphicsColor;
+
TColor = TGraphicsColor;</syntaxhighlight>
  
 
Und das selbe für '''forward defined classes''':
 
Und das selbe für '''forward defined classes''':
 
Zum Beispiel gibt es in TControl eine private Variable
 
Zum Beispiel gibt es in TControl eine private Variable
FHostDockSite: TWinControl;
+
<syntaxhighlight lang=pascal>FHostDockSite: TWinControl;</syntaxhighlight>
 
Find declaration auf TWinControl springt zur forward definition
 
Find declaration auf TWinControl springt zur forward definition
TWinControl = class;
+
<syntaxhighlight lang=pascal>TWinControl = class;</syntaxhighlight>
 
Und ein erneuter Aufruf springt zur realen Implementierung
 
Und ein erneuter Aufruf springt zur realen Implementierung
TWinControl = class(TControl)
+
<syntaxhighlight lang=pascal>TWinControl = class(TControl)</syntaxhighlight>
 
Auf diese Weise können Sie jeden Bezeichner aufspüren und jede Überladung finden.
 
Auf diese Weise können Sie jeden Bezeichner aufspüren und jede Überladung finden.
  
 
'''Tipps:'''  
 
'''Tipps:'''  
 
* Sie können zurück springen mit {{keypress|Strg|H}}.
 
* Sie können zurück springen mit {{keypress|Strg|H}}.
* Sie können alle besuchten Orte anzeigen/erreichen mittels Menü: Ansicht -> "Sprungliste anzeigen ..."
+
* Sie können alle besuchten Orte anzeigen/erreichen mittels Menü: Ansicht / Sprungliste anzeigen ...
 
* Mit einer 5-Tasten-Maus können Sie die beiden Extratasten dazu verwenden, vorwärts/rückwärts zu den besuchten Orten zu gehen
 
* Mit einer 5-Tasten-Maus können Sie die beiden Extratasten dazu verwenden, vorwärts/rückwärts zu den besuchten Orten zu gehen
:(Sie können die Tastenbelegung ändern mit Menü: Einstellungen --> Maus --> Erweitert  
+
:(Sie können die Tastenbelegung ändern mit Menü: Einstellungen / Maus / Erweitert  
 
Siehe auch:  [[IDE_Window:_EditorMouseOptionsAdvanced#Change_History_Jumps_for_3_button_Mouse_.28follow_back_the_.22Source_Link.22_trail.29|advanced mouse options]])
 
Siehe auch:  [[IDE_Window:_EditorMouseOptionsAdvanced#Change_History_Jumps_for_3_button_Mouse_.28follow_back_the_.22Source_Link.22_trail.29|advanced mouse options]])
  
==Identifier Completion==
+
==Bezeichner-Vervollständigung==
 
Die "Bezeichner-Vervollständigung" wird aufgerufen mittels {{keypress|Strg|space}}. Sie zeigt alle Bezeichner im Suchbereich. Zum Beipiel:
 
Die "Bezeichner-Vervollständigung" wird aufgerufen mittels {{keypress|Strg|space}}. Sie zeigt alle Bezeichner im Suchbereich. Zum Beipiel:
  
  procedure TForm1.FormCreate(Sender: TObject);
+
<syntaxhighlight lang=pascal>procedure TForm1.FormCreate(Sender: TObject);
  begin
+
begin
    |
+
  |
  end;
+
end;</syntaxhighlight>
  
 
Stellen Sie den Kursor zwischen ''begin'' und ''end'' und drücken Sie {{keypress|Strg|space}}. Die IDE/CodeTools untersuchen nun den gesamten erreichbaren Code und präsentieren Ihnen eine Liste aller gefundenen Bezeichner. Die CodeTools speichern die Ergebnisse zwischen, sodass ein neuerlicher Aufruf sehr viel schneller verläuft.
 
Stellen Sie den Kursor zwischen ''begin'' und ''end'' und drücken Sie {{keypress|Strg|space}}. Die IDE/CodeTools untersuchen nun den gesamten erreichbaren Code und präsentieren Ihnen eine Liste aller gefundenen Bezeichner. Die CodeTools speichern die Ergebnisse zwischen, sodass ein neuerlicher Aufruf sehr viel schneller verläuft.
Line 606: Line 602:
 
Die Bezeichner-Vervollständigung zeigt sogar solche Bezeichner an, die inkompatibel sind.
 
Die Bezeichner-Vervollständigung zeigt sogar solche Bezeichner an, die inkompatibel sind.
  
===Prefix===
+
===Präfix===
 
Sie könne die Bezeichner-Vervollständigung mitten in einem Wort starten. Dann werden die Buchstaben links als Präfix genommen. Zum Beispiel:
 
Sie könne die Bezeichner-Vervollständigung mitten in einem Wort starten. Dann werden die Buchstaben links als Präfix genommen. Zum Beispiel:
  
  procedure TForm1.FormCreate(Sender: TObject);
+
<syntaxhighlight lang=pascal>procedure TForm1.FormCreate(Sender: TObject);
  begin
+
begin
    Ca|ption
+
  Ca|ption
  end;
+
end;</syntaxhighlight>
  
 
Die Suchliste zeigt Ihnen dann nur diejenigen Bezeichner an, die mit 'Ca' beginnen.
 
Die Suchliste zeigt Ihnen dann nur diejenigen Bezeichner an, die mit 'Ca' beginnen.
Line 631: Line 627:
 
Wenn der Kursor in einer Klassendefinition steht und Sie die Vervollständigung aufrufen für eine in einer Vorfahren-Klasse definierten Methode, dann werden automatisch die Parameter und das Schlüsselwort 'override' angefügt. Zum Beispiel:
 
Wenn der Kursor in einer Klassendefinition steht und Sie die Vervollständigung aufrufen für eine in einer Vorfahren-Klasse definierten Methode, dann werden automatisch die Parameter und das Schlüsselwort 'override' angefügt. Zum Beispiel:
  
<Delphi>
+
<syntaxhighlight lang=pascal>TMainForm = class(TForm)
TMainForm = class(TForm)
 
 
protected
 
protected
 
   mous|
 
   mous|
end;
+
end;</syntaxhighlight>
</Delphi>
 
  
 
Die Vervollständigung von '''MouseDown''' ergibt:
 
Die Vervollständigung von '''MouseDown''' ergibt:
  
<Delphi>
+
<syntaxhighlight lang=pascal>TMainForm = class(TForm)
TMainForm = class(TForm)
 
 
protected
 
protected
 
   procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X,
 
   procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X,
 
         Y: Integer); override;
 
         Y: Integer); override;
end;
+
end;</syntaxhighlight>
</Delphi>
 
  
 
===Eigenschaften===
 
===Eigenschaften===
  
<Delphi>
+
<syntaxhighlight lang=pascal>property MyInt: integer read |;</syntaxhighlight>
property MyInt: integer read |;
 
</DELPHI>
 
  
 
Die Bezeichner-Vervollständigung zeigt Ihnen '''FMyInt''' und '''GetMyInt'''.
 
Die Bezeichner-Vervollständigung zeigt Ihnen '''FMyInt''' und '''GetMyInt'''.
  
<Delphi>
+
<syntaxhighlight lang=pascal>property MyInt: integer write |;</syntaxhighlight>
property MyInt: integer write |;
 
</DELPHI>
 
  
 
Die Bezeichner-Vervollständigung zeigt Ihnen '''FMyInt''' und '''SetMyInt'''.
 
Die Bezeichner-Vervollständigung zeigt Ihnen '''FMyInt''' und '''SetMyInt'''.
Line 668: Line 656:
 
===Anweisungen===
 
===Anweisungen===
  
<DELPHI>
+
<syntaxhighlight lang=pascal>procedure TMainForm.Button1Click(Sender: TObject);
procedure TMainForm.Button1Click(Sender: TObject);
 
 
begin
 
begin
 
   ModalRe|;
 
   ModalRe|;
end;
+
end;</syntaxhighlight>
</DELPHI>
 
  
 
wird zu:
 
wird zu:
  
<DELPHI>
+
<syntaxhighlight lang=pascal>procedure TMainForm.Button1Click(Sender: TObject);
procedure TMainForm.Button1Click(Sender: TObject);
 
 
begin
 
begin
 
   ModalResult:=|;
 
   ModalResult:=|;
end;
+
end;</syntaxhighlight>
</DELPHI>
 
  
 
==Wortvervollständigung==
 
==Wortvervollständigung==
Line 712: Line 696:
 
Kommentare vor einer Deklaration, ohne Leerzeile und nicht mit dem '''<'''-Zeichen beginnend:
 
Kommentare vor einer Deklaration, ohne Leerzeile und nicht mit dem '''<'''-Zeichen beginnend:
  
<Delphi>
+
<syntaxhighlight lang=pascal>var
var
 
 
   {Comment}
 
   {Comment}
   Identifier: integer;
+
   Identifier: integer;</syntaxhighlight>
</Delphi>
 
  
 
Kommentare mit dem '''<'''-Zeichen gehören zum vorhergehenden Bezeichner.
 
Kommentare mit dem '''<'''-Zeichen gehören zum vorhergehenden Bezeichner.
Line 722: Line 704:
 
Kommentare hinter einem Bezeichner in der selben Zeile:
 
Kommentare hinter einem Bezeichner in der selben Zeile:
  
<Delphi>
+
<syntaxhighlight lang=pascal>var  
var  
 
 
   identifier, // Comment
 
   identifier, // Comment
   other,
+
   other,</syntaxhighlight>
</Delphi>
 
  
 
Kommentare hinter der Definition in der selben Zeile:
 
Kommentare hinter der Definition in der selben Zeile:
  
<Delphi>
+
<syntaxhighlight lang=pascal>var
var
 
 
   identifier:  
 
   identifier:  
     char; // Comment
+
     char; // Comment</syntaxhighlight>
</Delphi>
 
  
 
Ein Beispiel für das '''<'''-Zeichen:
 
Ein Beispiel für das '''<'''-Zeichen:
  
<Delphi>
+
<syntaxhighlight lang=pascal>const
const
 
 
   a = 1;
 
   a = 1;
 
   //< comment for a
 
   //< comment for a
 
   b = 2;
 
   b = 2;
 
   // comment for c
 
   // comment for c
   c = 3;
+
   c = 3;</syntaxhighlight>
</Delphi>
 
  
 
Alle drei Kommentartypen werden unterstützt:
 
Alle drei Kommentartypen werden unterstützt:
<Delphi>
+
<syntaxhighlight lang=pascal> {Comment}(*Comment*)//Comment
  {Comment}(*Comment*)//Comment
+
   c = 1;</syntaxhighlight>
   c = 1;
 
</Delphi>
 
  
 
Kommentare, die mit '''$''' und '''%''' beginnen, werden ignoriert.
 
Kommentare, die mit '''$''' und '''%''' beginnen, werden ignoriert.
Line 759: Line 733:
 
Vorlaufende Kommentare, die mit einer Leerzeile abgetrennt werden, werden als unspezifisch für den folgenden Bezeichner angesehen. Beispielsweise wird der Kommentar für den folgenden Klassenheader nicht im Tipp angezeigt:
 
Vorlaufende Kommentare, die mit einer Leerzeile abgetrennt werden, werden als unspezifisch für den folgenden Bezeichner angesehen. Beispielsweise wird der Kommentar für den folgenden Klassenheader nicht im Tipp angezeigt:
  
<Delphi>
+
<syntaxhighlight lang=pascal>type
type
 
 
   { TMyClass }
 
   { TMyClass }
 
    
 
    
   TMyClass = class
+
   TMyClass = class</syntaxhighlight>
</Delphi>
 
  
 
Die Kommentare für Klassenheader werden bei der Klassenvervollständigung erzeugt. Sie können dies ausschalten unter ''Einstellungen / Codetools / Klassenvervollständigung / Header-Kommentar für die Klasse''. Falls Sie den Header-Kommentar im Tipp anzeigen wollen, entfernen Sie einfach die Leerzeile.
 
Die Kommentare für Klassenheader werden bei der Klassenvervollständigung erzeugt. Sie können dies ausschalten unter ''Einstellungen / Codetools / Klassenvervollständigung / Header-Kommentar für die Klasse''. Falls Sie den Header-Kommentar im Tipp anzeigen wollen, entfernen Sie einfach die Leerzeile.
Line 770: Line 742:
 
Der folgende Kommentar wird angezeigt für GL_TRUE, aber nicht für GL_FALSE:
 
Der folgende Kommentar wird angezeigt für GL_TRUE, aber nicht für GL_FALSE:
  
<Delphi>
+
<syntaxhighlight lang=pascal> // Boolean
  // Boolean
 
 
   GL_TRUE                          = 1;
 
   GL_TRUE                          = 1;
   GL_FALSE                          = 0;
+
   GL_FALSE                          = 0;</syntaxhighlight>
</Delphi>
 
 
 
[[Category:Lazarus]]
 

Latest revision as of 18:42, 21 February 2022

Deutsch (de) English (en) español (es) suomi (fi) français (fr) 日本語 (ja) 한국어 (ko) Nederlands (nl) português (pt) русский (ru) slovenčina (sk) 中文(中国大陆)‎ (zh_CN)

Überblick

Die IDE verwendet eine Bibliothek von Werkzeugen zum Analysieren und Bearbeiten von Pascal-Quelltexten, genannt die "CodeTools". Diese Werkzeuge bieten Features wie Deklaration finden, Codevervollständigung, Isolation, Verschieben, Einfügen und Verschönern von Pascal-Quelltext. Diese Funktionen sparen Ihnen eine Menge Zeit und doppelte Arbeit. Sie können angepasst werden. Jedes Feature ist über Tastenkombinationen verfügbar (siehe Editoreinstellungen).

Weil sie ausschließlich mit Quelltexten arbeiten und den Code von FPC, Delphi und Kylix verstehen, benötigen sie weder kompilierte Units noch einen installierten Borland Compiler. Sie können Delphi- und FPC-Code zur gleichen Zeit bearbeiten. Sie können sogar mit verschiedenen Delphi- und FPC-Versionen zur selben Zeit arbeiten. Dies macht die Portierung von Delphi-Code sehr viel einfacher.

Übersichtstabelle der IDE-Tastenkombinationen

Declaration Jumping Strg+Klick (springt zur Deklaration eines Typs oder einer Variablen)
Methodenspringen Strg+ Shift+ (schaltet zwischen Definition und Rumpf einer Prozedur/Methode um)
Code-Schablonen Strg+J
Synchronbearbeitung Strg+J (bei ausgewähltem Text)
Codevervollständigung (Klassenvervollständigung) Strg+ Shift+C
Bezeichner-Vervollständigung Strg+Space
Wortvervollständigung Strg+W
Parameter-Hinweise Strg+ Shift+Space
Inkrementelle Suche Strg+E
Bezeichner umbenennen Strg+ Shift+E

Methodenspringen

Um zwischen einem Prozedurrumpf (begin..end) und der Prozedurdefinition (procedure Name;) zu springen, verwenden Sie Strg+ Shift+Nach oben.

Zum Beispiel:

interface

procedure DoSomething; // Prozedurdefinition

implementation

procedure DoSomething; // Prozedurrumpf 
begin
end;

Wenn der Cursor auf dem Prozedurrumpf ist und Sie Strg+ Shift+Nach oben drücken, dann wird der Kursor zur Definition springen. Erneutes Drücken von Strg+ Shift+Nach oben wird wieder zum Rumpf springen, nach 'begin'.

Dies funktioniert ebenfalls zwischen Methoden (Prozeduren in Klassen).

Hinweise: Methodenspringen springt zur selben Prozedur mit dem selben Namen und Parameterliste. Wenn es keine bestimmte Prozedur gibt, springt es zum besten Kandidaten und positioniert den Kursor auf dem ersten Unterschied. (Für Delphianer: Delphi kann dies nicht tun).

Zum Beispiel eine Prozedur mit verschiedenen Parametertypen:

interface

procedure DoSomething(p: char); // Prozedurdefinition

implementation
  
procedure DoSomething(p: string); // Prozedurrumpf
begin
end;

Das Springen von der Definition zum Rumpf wird den Kursor auf dem 'string' Schlüsselwort positionieren. Dies kann verwendet werden für das Umbenennen von Methoden und/oder das Ändern von Parametern.

Zum Beispiel:
Sie benannten 'DoSomething' in 'MakeIt' um:

interface

procedure MakeIt; // Prozedurdefinition

implementation

procedure DoSomething; // Prozedurrumpf
begin
end;

Dann springen Sie von MakeIt zum Rumpf. Die IDE sucht nach einem passenden Rumpf, findet keinen, und sucht daher nach einem Kandidaten. Weil Sie nur eine Prozedur umbenannt haben, gibt es exakt einen Rumpf ohne Definition (DoSomething) und daher wird sie zu DoSomething springen und den Kursor rechts neben 'DoSomething' positionieren. Dann können Sie sie dort auch umbenennen. Das funktioniert ebenfalls für Parameter.

Include-Dateien

Include-Dateien sind Dateien, die mit der ($I Dateiname) oder ($INCLUDE Dateiname) Compilerdirektive in die Quellen eingefügt werden. Lazarus und FPC verwenden oft Include-Dateien, um Redundanz zu reduzieren und unlesbare ($IFDEF) Konstrukte zu vermeiden um verschiedene Plattformen zu unterstützen.

Im Gegensatz zu Delphi bietet die Lazarus IDE volle Unterstützung für Include-Dateien. Sie können zum Beispiel von der Methode in der .pas Datei zum Methodenrumpf in der Include-Datei springen. Alle CodeTools wie Codevervollständigung berücksichtigen Include-Dateien als spezielle Schranken.

Zum Beispiel: Wenn die Codevervollständigung einen neuen Methodenrumpf hinzufügt hinter anderen Methodenrümpfen, behält sie beide in der selben Datei. Auf diese Weise können Sie ganze Klassenimplementierungen in Include-Dateien verwenden, wie es die LCL für nahezu alle Bedienelemente tut.

Aber es gibt eine Anfängerfalle: Wenn Sie eine Include-Datei zum ersten Mal öffnen und method jumping oder find declaration ausprobieren, erhalten Sie eine Fehlermeldung. Die IDE weiß nicht, zu welcher Unit die Include-Datei gehört. Sie müssen die Unit zuerst öffnen.

Sobald die IDE die Unit analysiert, wird sie die Include-Direktive dort finden und die IDE wird sich an diese Beziehung erinnern. Sie wird diese Informationen beim Beenden (oder beim Speichern des Projekts) speichern in der Datei ~/.lazarus/includelinks.xml. Wenn Sie diese Include-Datei das nächste Mal öffnen und eine 'find declaration' durchführen, wird die IDE die Unit intern öffnen und das Springen wird funktionieren. Sie können die IDE auch direkt hinweisen mit

{%mainunit yourunit.pas}

am Anfang Ihrer yourinclude.inc.

Dieser Mechanismus hat natürlich Grenzen. Einige Include-Dateien sind zweimal oder mehrfach einbezogen. Zum Beispiel: lcl/include/winapih.inc.

Das Springen von den Prozedur-/Methodendefinitionen in diese Include-Datei zu den Rümpfen hängt von Ihren letzten Aktionen ab. Wenn Sie an lcl/lclintf.pp gearbeitet haben dann wird die IDE zu winapi.inc springen. Wenn Sie an lcl/interfacebase.pp gearbeitet haben, dann wird sie zu lcl/include/interfacebase.inc springen (oder einer der anderen Include-Dateien). Wenn Sie an beiden arbeiten, dann können Sie verwirrt werden. ;)

Code-Schablonen

Code-Schablonen konvertieren einen Bezeichner in einen Text oder Code-Fragment.

Die Code-Schablonen Vorgabetastenkombination ist Strg+J. Sie können einen Bezeichner eintippen, Strg+J drücken und der Bezeichner wird durch den Text ersetzt, der für den Bezeichner definiert ist. Code-Schablonen können definiert werden in Werkzeuge -> Vorlagen.

Beispiel: Schreiben Sie den Bezeichner 'classf', lassen Sie den Kursor hinter dem 'f' stehen und drücken Sie Strg+J. Das 'classf' wird ersetzt durch

T = class(T)
private

public
  constructor Create;
  destructor Destroy; override;
end;

und der Cursor ist hinter dem 'T'. Sie können die Liste der Vorlagen abrufen, in dem Sie den Kursor an eine freie Stelle positionieren (nicht auf einem Bezeichner) und Strg+J drücken. Die Liste der Code-Schablonen wird auftauchen. Verwenden Sie die Kursortasten oder tippen Sie einige Buchstaben um eine auszuwählen. Eingabe erzeugt die gewählte Vorlage und Escapeschließt das Popup-Fenster.

Die größten Zeitsparer sind die Schablonen 'b'+Strg+J für begin..end.

Parameter-Hinweise

Parameter-Hinweise zeigen eine Hinweisbox mit den Parameter-Deklarationen für die aktuelle Parameterliste.

Zum Beispiel

  Canvas.FillRect(|);

Platzieren Sie den Cursor in den Klammern und drücken Sie Strg+ Shift+Leertaste. Eine Hinweisbox erscheint mit den Parametern von FillRect.

Parameterhints1.png

Seit Version 0.9.31 gibt es eine Schaltfläche rechts neben jeder Deklaration um fehlende Parameters einzufügen. Diese kopiert die Parameternamen aus der ausgewählten Deklaration an die Kursorposition.

Parameterhints2.png

Tipp: Benutzen Sie die Variable Declaration Completion um Variablen zu deklarieren.

Beachten Sie: Der Name des Tastenkürzels ist "Code-Context anzeigen".

Inkrementelle Suche

Die inkrementelle Suche ändert die Statuszeile des Quelltexteditors. Geben Sie ein paar Zeichen ein und der Editor sucht und markiert sofort alle Fundstellen im Text. Das Tastaturkürzel ist Strg+E.

  • Zum Beispiel: Sie drücken A, sucht und markiert alle Fundstellen von 'A'.
  • Dann drücken Sie T und alle Fundstellen von 'at' sind markiert usw.
  • Sie springen zur nächsten Fundstelle mit F3 (oder Strg+E während der Suche) und zur vorigen Fundstelle mit Umschalt+F3.
  • ← Backspace entfernt das letzte Zeichen
  • Eingabe stoppt die Suche ohne eine neue Zeile im Editor.
  • Sie nehmen die letzte Suche erneut auf mit einem zweiten Strg+E, sofort nach dem Start der Suche mit Strg+E. Das gilt solange das Suchfeld noch leer ist.
  • Einfügen mit Strg+V hängt den Text aus der Zwischenablage an den aktuellen Suchtext an (seit Lazarus 0.9.27 r19824).

Hinweis: Schnelle Suche nach einem Bezeichner mit der inkrementellen Suche

  • Stellen Sie den Textkursor auf den Bezeichner. (Wählen Sie nichts aus!)
  • Drücken Sie Strg+C. Der Editor wählt den Bezeichner aus und kopiert ihn in die Zwischenablage
  • Drücken Sie Strg+E - startet die inkrementelle Suche
  • Drücken Sie Strg+V - sucht nach dem Bezeichner (seit Version 0.9.27)
  • Mit F3 und Umschalt+F3 springen Sie zum nächsten/vorigen Fund.
  • Mit einer beliebigen Taste (beispielsweise Kursor links oder rechts) beenden Sie die Suche

Synchronbearbeitung

Die Synchronbearbeitung ermöglicht es Ihnen, alle Fundstellen eines Wortes gleichzeitig (synchronisiert) zu bearbeiten. Sie bearbeiten einfach das Wort an einer Stelle und gleichzeitig mit Ihren Eingaben werden auch alle anderen Fundstellen des Wortes aktualisiert.

Die Synchronbearbeitung verarbeitet alle Worte in einem ausgewählten Bereich:

  • Selektieren Sie einen Textblock
  • Drücken Sie Strg+J oder klicken Sie auf das Symbol in der Randleiste. (Das funktioniert nur, wenn Worte in der Auswahl mehr als einmal auftreten.)
  • Benutzen Sie die Tab -Taste, um das zu bearbeitende Wort auszuwählen (wenn einige verschiedene Wörter mehrfach auftreten).
  • Bearbeiten Sie das Wort.
  • Drücken Sie Esc zum Beenden

Sehen Sie sich hier ein animiertes Beispiel an.

  • Anmerkung: Strg+J wird auch beim Bearbeiten von Vorlagen benutzt. Die Bedeutung ändert sich, wenn Sie einen Text auswählen.

Suche nächste / vorhergehende Fundstelle des Wortes

Die zwei Funktionen sind im Kontextmenü des Quelltexteditors zu finden

  • Quelltexteditor / Kontextmenü / Suchen / Nächste Fundstelle des Wortes
  • Quelltexteditor / Kontextmenü / Suchen / Vorhergehende Fundstelle des Wortes

Und Sie können diesen Funktionen in den Editoreinstellungen ein Tastenkürzel zuweisen.

Codevervollständigung

Die Codevervollständigung ist im IDE-Menü zu finden unter Bearbeiten -> Quelltext vervollständigen und hat das Standardkürzel Strg+ Shift+C.

Für Delphianer: Delphi bezeichnet mit "Codevervollständigung" die Funktion, die die Liste der Bezeichner an der aktuellen Quellenposition zeigt (Strg+Leertaste). Unter Lazarus wird dies Bezeichnervervollständigung genannt.

Codevervollständigung kombiniert verschiedene mächtige Funktionen. Beispiele:

Welche Funktion genutzt wird, hängt von der Kursorposition im Editor ab und wird unten beschrieben.

Die Codevervollständigung ist im IDE-Menü zu finden unter Bearbeiten -> Quelltext vervollständigen und hat das Standardkürzel Strg+ Shift+C.

Class Completion

Das mächtigste Codevervollständigungs-Feature ist Class Completion. Sie schreiben eine Klasse, fügen die Methoden und Eigenschaften hinzu und Codevervollständigung wird die Methodenrümpfe hinzufügen, die Methoden/Variablen des Eigenschaftszugriffs und die private Variablen.

Zum Beispiel: Erzeugen Sie eine Klasse (siehe Code-Schablonen, um einige Tipparbeit zu sparen):

TExample = class(TObject)
public
  constructor Create;
  destructor Destroy; override;
end;

Positionieren Sie den Kursor irgendwo in der Klasse und drücken Sie Strg+ Shift+C. Dies wird die fehlenden Methodenrümpfe erzeugen und den Kursor zu dem ersten erzeugten Methodenrumpf bewegen, so dass Sie jetzt mit dem Schreiben des Klassencodes beginnen können:

{ TExample }

constructor TExample.Create;
begin
  |
end;

destructor TExample.Destroy;
begin
  inherited Destroy;
end;

Anmerkung: Das '|' ist der Kursor und nicht hinzugefügt.

Hinweis: Sie können zwischen einer Methode und ihrem Rumpf springen mit Strg+ Shift+Nach oben.

Sie können sehen, dass die IDE auch den 'inherited Destroy' Aufruf hinzugefügt hat. Dies passiert, wenn es ein 'override' Schlüsselwort in der Klassendefinition gibt.

Jetzt fügen Sie eine Methode DoSomething hinzu:

TExample = class(TObject)
public
  constructor Create;
  procedure DoSomething(i: integer);
  destructor Destroy; override;
end;

Dann drücken Sie Strg+ Shift+C und die IDE wird hinzufügen:

procedure TExample.DoSomething(i: integer);
begin
  |
end;

Sie sehen, der neue Methodenrumpf wurde zwischen Create und Destroy eingefügt, exakt wie in der Klassendefinition. So behalten auch die Methodenrümpfe die gleiche logische Ordnung bei (wie von Ihnen festgelegt). Sie legen die Einfügerichtlinien fest in Einstellungen -> Codetools Einstellungen -> Quelltexterzeugung.

Complete Properties
Fügen Sie eine Eigenschaft 'AnInteger' hinzu:

TExample = class(TObject)
public
  constructor Create;
  procedure DoSomething(i: integer);
  destructor Destroy; override;
  property AnInteger: Integer;
end;

Drücken Sie Ctrl+ Shift+C und Sie erhalten:

procedure TExample.SetAnInteger(const AValue: integer);
begin
  |if FAnInteger=AValue then exit;
  FAnInteger:=AValue;
end;

Die Codevervollständigung hat den Schreibzugriff geändert und den üblichen Code ergänzt. Springen Sie mit Strg+ Shift+Nach oben zur Klasse, um die neue Klasse ganz zu sehen:

TExample = class(TObject)
private
  FAnInteger: integer;
  procedure SetAnInteger(const AValue: integer);
public
  constructor Create;
  procedure DoSomething(i: integer);
  destructor Destroy; override;
  property AnInteger: integer read FAnInteger write SetAnInteger;
end;

Die Eigenschaft wurde um einen Lese- und Schreibzugriff erweitert. Die Klasse erhielt den neuen Abschnitt 'private' mit einer Variable 'FAnInteger' und der Methode 'SetAnInteger'. Es ist eine allgemein übliche Delphi-Stil-Regel, den privaten Variablen ein 'F' und der write-Methode ein 'Set' voranzustellen. Wenn Sie das nicht mögen, können Sie es ändern unter Einstellungen -> Codetools Einstellungen -> Quelltexterzeugung.

Erzeugen einer Eigenschaft 'read only':

property PropName: PropType read;

wird erweitert zu

property PropName: PropType read FPropName;

Erzeugen einer Eigenschaft 'write only':

property PropName: PropType write;

wird erweitert zu

property PropName: PropType write SetPropName;

Erzeugen einer Eigenschaft 'read only' mit einer Read-Methode:

property PropName: PropType read GetPropName;

wird beibehalten und eine Funktion 'GetPropName' wird angefügt:

function GetpropName: PropType;

Erzeugen einer Eigenschaft mit einem stored-Modifizierer:

property PropName: PropType stored;

wird erweitert zu

property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;

Weil 'stored' für das Streaming benutzt wird, werden automatisch auch die read- und write-Modifizierer angefügt.

Hinweis: Die Bezeichnervervollständigung erkennt auch unvollständige Eigenschaften und wird die Standardnamen vorschlagen. Zum Beispiel:

property PropName: PropType read |;

Platzieren Sie den Kursor eine Leerstelle hinter dem 'read'-Schlüsselwort und drücken Strg+Space für die Bezeichnervervollständigung. Diese wird Ihnen die Variable 'FPropName' und die Prozedur 'SetPropName' präsentieren.

Forward Procedure Completion

Die Forward Procedure Completion ist ein Teil der Codevervollständigung und fügt fehlende Prozedurrümpfe hinzu. Sie wird aufgerufen, wenn der Kursor auf einer vorwärts definierten Prozedur ist.

Zum Beispiel: Fügen Sie eine neue Prozedur zum Interface-Abschnitt hinzu:

procedure DoSomething;

Platzieren Sie den Kursor darauf und drücken Sie Strg+ Shift+C für Codevervollständigung. Es wird im Implementation-Abschnitt erzeugen:

procedure DoSomething;
begin
  |
end;

Hinweis: Sie können zwischen einer Prozedurdefinition und ihrem Rumpf springen mit Strg+ Shift+Nach oben.

Der neue Prozedurrumpf wird vor den Klassenmethoden eingefügt. Wenn es bereits einige Prozeduren im Interface-Abschnitt gibt, versucht die IDE die Ordnung einzuhalten. Zum Beispiel:

procedure Proc1;
procedure Proc2; // neue Prozedur
procedure Proc3;

Wenn die Rümpfe von Proc1 und Proc3 bereits existieren, dann wird der Proc2 Rumpf zwischen den Rümpfen von Proc1 und Proc3 eingefügt. Dieses Verhalten kann eingestellt werden in Einstellungen -> CodeTools Einstellungen -> Quelltexterzeugung.

Mehrere Prozeduren:

procedure Proc1_Old; // Rumpf existiert
procedure Proc2_New; // Rumpf existiert nicht
procedure Proc3_New; //  "
procedure Proc4_New; //  "
procedure Proc5_Old; // Rumpf existiert

Die Codevervollständigung wird alle 3 Prozedurrümpfe hinzufügen (Proc2_New, Proc3_New, Proc4_New).

Warum wird das Forward Procedure Completion genannt?

Weil es nicht nur für Prozeduren funktioniert, die im Interface definiert sind, sondern auch für Prozeduren mit dem "forward"-Bezeichner. Und weil die CodeTools Prozeduren im Interface so behandeln als hätten sie einen impliziten "forward"-Bezeichner.

Event Assignment Completion

Die "Event Assignment Completion" ist ein Teil der Codevervollständigung und komplettiert eine einzelne Ereignis:=| Anweisung. Sie wird aufgerufen, wenn der Kursor hinter einer Ereigniszuweisung steht.

Zum Beispiel: In einer Methode, sagen wir dem FormCreate Ereignis, fügen wir eine Zeile 'OnPaint:=' hinzu:

procedure TForm1.Form1Create(Sender: TObject);
begin
  OnPaint:=|
end;

Das '|' ist der Kursor und sollte nicht eingegeben werden. Dann drücken sie Strg+Shift+C für die Codevervollständigung. Die Anweisung wird komplettiert zu

OnPaint:=@Form1Paint;

Eine neue Methode Form1Paint wird zur Klasse TForm1 hinzugefügt. Dann wird die class completion gestartet und Sie erhalten:

procedure TForm1.Form1Paint(Sender: TObject);
begin
  |
end;

Das funktioniert wie das Hinzufügen von Methoden im Objektinspektor.

Anmerkung:
Sie müssen den Kursor hinter dem ':=' Zuweisungsoperator platzieren. Wenn Sie den Kursor auf dem Bezeichner platzieren (z.B. OnPaint) wird die Codevervollständigung die "Local Variable Completion" aufrufen, was fehlschlägt, weil OnPaint bereits definiert ist.

Hinweis:
Sie können den neuen Methodennamen selbst definieren. Zum Beispiel:

OnPaint:=@ThePaintMethod;

Variable Declaration Completion

Die "Variable Declaration Completion" ist ein Teil der Codevervollständigung und fügt eine lokale Variablendefinition zu einer Identifier:=Term; Anweisung hinzu. Sie wird aufgerufen, wenn der Kursor auf dem Bezeichner in einer Zuweisung oder einem Parameter ist.

Zum Beispiel:

procedure TForm1.Form1Create(Sender: TObject);
begin
  i:=3;
end;

Platzieren Sie den Kursor auf dem 'i' oder genau dahinter. Dann drücken Sie Strg+ Shift+C für die Codevervollständigung und Sie erhalten:

procedure TForm1.Form1Create(Sender: TObject);
var
  i: Integer;
begin
  i:=3;
end;

Die CodeTools prüfen zuerst, ob der Bezeichner 'i' bereits definiert ist und wenn nicht werden sie die Deklaration 'var i: integer;' hinzufügen. Der Typ des Bezeichners wird erraten vom Ausdruck rechts des ':=' Zuweisungsoperators. Zahlen wie die 3 sind mit Integer vorbelegt.

Ein anderes Beispiel:

type
  TWhere = (Behind, Middle, InFront);
 
  procedure TForm1.Form1Create(Sender: TObject);
  var
    a: array[TWhere] of char;
  begin
    for Where:=Low(a) to High(a) do writeln(a[Where]);
  end;

Platzieren Sie den Kursor auf 'Where' und drücken Sie Strg+ Shift+C für die Codevervollständigung. Sie erhalten:

  procedure TForm1.Form1Create(Sender: TObject);
  var
    a: array[TWhere] of char;
    Where: TWhere;
  begin
    for Where:=Low(a) to High(a) do writeln(a[Where]);
  end;

Seit Version 0.9.11 komplettiert Lazarus auch Parameter. Zum Beispiel

  procedure TForm1.FormPaint(Sender: TObject);
  begin
    with Canvas do begin
      Line(x1,y1,x2,y2);
    end;
  end;

Platzieren Sie den Kursor auf 'x1' und drücken Sie Strg+ Shift+C für die Codevervollständigung. Sie erhalten:

  procedure TForm1.FormPaint(Sender: TObject);
  var
    x1: integer;
  begin
    with Canvas do begin
      Line(x1,y1,x2,y2);
    end;
  end;

Procedure Call Completion

Die Codevervollständigung kann auch eine neue Prozedur aus dem Prozeduraufruf selbst erzeugen.

Angenommen, Sie haben gerade die Anweisung "DoSomething(Width);" geschrieben

procedure SomeProcedure;
var
  Width: integer;
begin
  Width:=3;
  DoSomething(Width);
end;

Platzieren Sie den Kursor über dem Bezeichner "DoSomething" und drücken Sie Strg+ Shift+C. Sie erhalten:

procedure DoSomething(aWidth: LongInt);
begin

end;

procedure SomeProcedure;
var
  Width: integer;
begin
  Width:=3;
  DoSomething(Width);
end;

Es werden derzeit noch keine Funktionen oder Methoden erzeugt.

Reversed Class Completion

"Reversed Class Completion" ist ein Teil der Codevervollständigung und fügt eine private Methodendeklaration zum aktuellen Methodenrumpf hinzu. Sie wird aufgerufen, wenn der Cursor in einem Methodenrumpf ist, der noch nicht in der Klasse definiert wurde. Dieses Feature ist seit Lazarus 0.9.21 verfügbar.

Zum Beispiel:

  procedure TForm1.DoSomething(Sender: TObject);
  begin
  end;

Die Methode DoSomething ist noch nicht in TForm1 deklariert. Drücken Sie Strg+ Shift+C und die IDE wird "procedure DoSomething(Sender: TObject);" zu den privaten Methoden von TForm1 hinzufügen.

Für Delphianer: Die Klassenergänzung arbeitet unter Lazarus immer in einer Richtung: Von dem Klasseninterface zur Implementation oder rückwärts/umgekehrt von der Klassenimplementation zum Interface. Delphi ruft immer beide Richtungen auf. Das Delphi-Verfahren hat den Nachteil, dass bei einem Rechtschreibfehler leicht eine neue Methodenvorlage erzeugt wird ohne Benachrichtigung.

Kommentare und Codevervollständigung

Die Codevervollständigung versucht die Kommentare dort zu behalten, wo sie hingehören. Zum Beispiel:

  FList: TList; // list of TComponent
  FInt: integer;

Wenn eine neue Variable zwischen FList und FInt eingesetzt wird, dann wird der Kommentar in der FList Zeile beibehalten. Das selbe gilt für

  FList: TList; { list of TComponent
    Dies ist ein Kommentar über mehrere Zeilen, beginnend
    in der FList-Zeile. Die CodeTools nehmen an, er gehöre 
    zu der FList-Zeile und brechen diese Beziehung nicht
    auf. Der Code wird hinter dem Kommentar eingefügt. }
  FInt: integer;

Wenn der Kommentar in der nächsten Zeile startet, dann wird er behandelt, wie wenn er zum nachfolgenden Code gehört. Zum Beispiel:

  FList: TList; // list of TComponent
    { Dieser Kommentar gehört zur nachfolgenden Anweisung. 
      Neuer Code wird oberhalb des Kommentars eingefügt und 
      hinter dem Kommentar der FList-Zeile. }
  FInt: integer;

Method update

Normalerweise fügt die Klassenergänzung alle fehlenden Methodenrümpfe ein. (Seit Version 0.9.27) Falls sich aber genau eine Methode zwischen Klassendeklaration und Rümpfen unterscheidet, dann wird der Methodenrumpf aktualisiert. Zum Beispiel: Sie haben eine Methode DoSomething.

  public
    procedure DoSomething;
  end;

procedure TForm.DoSomething;
begin
end;

Fügen Sie jetzt einen Parameter hinzu:

  public
    procedure DoSomething(i: integer);
  end;

und rufen Sie die Codevervollständigung auf mit (Strg+ Shift+C). Der Methodenrumpf wird aktualisiert und der neue Parameter wird kopiert:

procedure TForm.DoSomething(i: integer);
begin
end;

Refactoring

Invert Assignments

Kurz gefasst
"Invert Assignments" nimmt einige ausgewählte Pascal-Anweisungen und invertiert alle Zuweisungen aus diesem Code. Dieses Werkzeug ist hilfreich für das Umwandeln eines "Speicher"-Codes in einen "Lade"-Code und umgekehrt.

Beispiel:

procedure DoSomething;
begin
  AValueStudio:= BValueStudio;
  AValueAppartment :=BValueAppartment;
  AValueHouse:=BValueHouse;
end;

Wählen Sie die Zeilen mit den Zuweisungen aus (zwischen begin und end) und führen Sie "Invert Assignments" aus. Alle Zuweisungen werden invertiert und die Einrückung wird automatisch hinzugefügt. Zum Beispiel:

Resultat:

procedure DoSomething;
begin
  BValueStudio     := AValueStudio;
  BValueAppartment := AValueAppartment;
  BValueHouse      := AValueHouse;
end;

Enclose Selection

Wählen Sie einigen Text aus und rufen Sie die Vervollständigung auf. In dem aufscheinenden Dialog können Sie auswählen, ob der selektierte Text in try..finally oder einen der vielen anderen üblichen Blöcke eingeschlossen werden soll.

Bezeichner umbenennen

Stellen Sie den Kursor auf einen Bezeichner und rufen Sie die Vervollständigung auf. Es erscheint ein Dialog, wo Sie den Suchbereich und den neuen Namen festlegen können.

  • Es werden alle Vorkommen umbenannt und zwar nur jene, die tatsächlich diese Deklaration verwenden. Das bedeutet, dass nicht automatisch alle Deklarationen mit dem selben Namen umbenannt werden.
  • Und es wird zuerst auf Namenskonflikte überprüft.
  • Beschränkungen: Das funktioniert nur mit Pascal-Quellen, benennt keine Dateinamen um und bearbeitet weder lfm/lrs-Dateien noch lazdoc-Dateien.

Find Identifier References

Stellen Sie den Kursor auf einen Bezeichner und rufen Sie die Vervollständigung auf. Es erscheint ein Dialog, wo Sie den Suchbereich festlegen können. Die IDE sucht dann nach allen Vorkommen und nur solchen, die tatsächlich diese Deklaration verwenden. Das bedeutet, dass nicht andere Deklarationen mit dem selben Namen angezeigt werden.

Show abstract methods

Dieses Merkmal listet und ergänzt automatisch virtuelle, abstrakte Methoden, die noch implementiert werden müssen. Stellen Sie den Kursor auf eine Klassendeklaration und rufen Sie die Vervollständigung auf. Falls es fehlende abstrakte Methoden gibt, werden diese in einem Dialog aufgelistet. Wählen Sie die zu implementierende Methode aus und die IDE erzeugt eine Methodenschablone.

Prozedur extrahieren

Siehe Prozedur extrahieren

Find Declaration

Positionieren Sie den Kursor auf einem Bezeichner und starten Sie Find Declaration. Das wird die Deklaration dieses Bezeichners suchen, die Datei öffnen und zu ihr springen. Falls der Kursor bereits auf der Deklaration ist, erfolgt ein Sprung zur vorherigen Deklaration mit dem selben Name. Dies erlaubt es, Neudefinitionen und Overrides zu finden.

Jede find declaration setzt einen Sprungpunkt. Das bedeutet, Sie springen mit find declaration zur Deklaration und einfach zurück mit Suche -> Zurückspringen.

Es gibt einige Unterschiede zu Delphi: Die CodeTools arbeiten mit den Quellen, den normalen Pascal-Regeln folgend, anstelle der Verwendung der Compiler-Ausgaben. Der Compiler liefert den finalen Typ zurück. Die CodeTools sehen die Quellen und alle Schritte dazwischen. Zum Beispiel:

Die Visible Eigenschaft wird zuerst in TControl (controls.pp) definiert, dann neu definiert in TCustomForm und letztlich in TForm neu definiert. Das Aufrufen von find declaration auf Visible wird Sie zuerst zu Visible in TForm bringen. Dann können Sie Find Declaration erneut aufrufen um zu Visible in TCustomForm zu springen und nochmals, um zu Visible in TControl zu springen.

Das selbe gilt für Typen wie TColor. Für den Compiler ist es einfach ein 'longint'. Aber in den Quellen ist es definiert als

TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;
TColor = TGraphicsColor;

Und das selbe für forward defined classes: Zum Beispiel gibt es in TControl eine private Variable

FHostDockSite: TWinControl;

Find declaration auf TWinControl springt zur forward definition

TWinControl = class;

Und ein erneuter Aufruf springt zur realen Implementierung

TWinControl = class(TControl)

Auf diese Weise können Sie jeden Bezeichner aufspüren und jede Überladung finden.

Tipps:

  • Sie können zurück springen mit Strg+H.
  • Sie können alle besuchten Orte anzeigen/erreichen mittels Menü: Ansicht / Sprungliste anzeigen ...
  • Mit einer 5-Tasten-Maus können Sie die beiden Extratasten dazu verwenden, vorwärts/rückwärts zu den besuchten Orten zu gehen
(Sie können die Tastenbelegung ändern mit Menü: Einstellungen / Maus / Erweitert

Siehe auch: advanced mouse options)

Bezeichner-Vervollständigung

Die "Bezeichner-Vervollständigung" wird aufgerufen mittels Strg+space. Sie zeigt alle Bezeichner im Suchbereich. Zum Beipiel:

procedure TForm1.FormCreate(Sender: TObject);
begin
  |
end;

Stellen Sie den Kursor zwischen begin und end und drücken Sie Strg+space. Die IDE/CodeTools untersuchen nun den gesamten erreichbaren Code und präsentieren Ihnen eine Liste aller gefundenen Bezeichner. Die CodeTools speichern die Ergebnisse zwischen, sodass ein neuerlicher Aufruf sehr viel schneller verläuft.

Anmerkung für Delphianer: Delphi nennt das Code completion.

Einige Bezeichner wie 'Write', 'ReadLn', 'Low', 'SetLength', 'Self', 'Result', 'Copy' sind in den Compiler eingebaut und nirgends sonst im Quellcode definiert. Die Bezeichner-Vervollständigung hat ebenfalls viele solche Dinge eingebaut. Falls Ihnen eines fehlt, schreiben Sie einfach einen Wunsch ("feature request") im Bug-Tracker.

Die Bezeichner-Vervollständigung ergänzt nicht alle Schlüsselwörter. So können Sie sie nicht dazu benutzen 'repe' zu 'repeat' zu ergänzen. Nehmen Sie dafür Strg+W Wortvervollstandigung oder Strg+J Code-Schablonen. Seit Version 0.9.27 ergänzt die Bezeichner-Vervollständigung einige Schlüsselwörter.

Die Bezeichner-Vervollständigung zeigt sogar solche Bezeichner an, die inkompatibel sind.

Präfix

Sie könne die Bezeichner-Vervollständigung mitten in einem Wort starten. Dann werden die Buchstaben links als Präfix genommen. Zum Beispiel:

procedure TForm1.FormCreate(Sender: TObject);
begin
  Ca|ption
end;

Die Suchliste zeigt Ihnen dann nur diejenigen Bezeichner an, die mit 'Ca' beginnen.

Tasten

  • Buchstabe oder Ziffer: füge das Zeichen hinzu im Quelltexteditor und im aktuellen Präfix. Dadurch wird die Liste aktualisiert.
  • Backspace: entfernt das letzte Zeichen aus dem Quelltexteditor und dem Präfix. Aktualisiert die Liste.
  • Eingabe: ersetzt das ganze Wort am Kursor mit dem ausgewählten Bezeichner und schließt das Popup-Fenster.
  • Umschalt+Eingabe: wie Eingabe, aber ersetzt nur das Präfix (linker Teil) des Wortes am Kursor.
  • Nach oben/Nach unten: bewegt die Auswahl
  • Escape: schließt das Popup-Fenster ohne Änderungen
  • Tab: ergänzt das Präfix zur nächsten Auswahl. Zum Beispiel: Das aktuelle Präfix ist 'But' und die Bezeichner-Vervollständigung zeigt nur 'Button1' und 'Button1Click'. Durch Drücken von Tab wird das Präfix zu 'Button1' ergänzt.
  • Else: wie Eingabe und fügt das Zeichen zum Quelltexteditor hinzu

Methoden

Wenn der Kursor in einer Klassendefinition steht und Sie die Vervollständigung aufrufen für eine in einer Vorfahren-Klasse definierten Methode, dann werden automatisch die Parameter und das Schlüsselwort 'override' angefügt. Zum Beispiel:

TMainForm = class(TForm)
protected
  mous|
end;

Die Vervollständigung von MouseDown ergibt:

TMainForm = class(TForm)
protected
  procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X,
         Y: Integer); override;
end;

Eigenschaften

property MyInt: integer read |;

Die Bezeichner-Vervollständigung zeigt Ihnen FMyInt und GetMyInt.

property MyInt: integer write |;

Die Bezeichner-Vervollständigung zeigt Ihnen FMyInt und SetMyInt.

Uses-Abschnitt / Unitnamen

In Uses-Abschnitten zeigt die Bezeichner-Vervollständigung die Dateinamen aller Units im Suchpfad. Diese werden immer in Kleinbuchstaben angezeigt (z.B. avl_tree), weil die meisten Units ohnehin kleinbuchstabige Dateinamen haben. Bei der Vervollständigung wird aber die "niedliche" Schreibweise für Dateinamen eingesetzt (z.B. AVL_Tree).

Anweisungen

procedure TMainForm.Button1Click(Sender: TObject);
begin
  ModalRe|;
end;

wird zu:

procedure TMainForm.Button1Click(Sender: TObject);
begin
  ModalResult:=|;
end;

Wortvervollständigung

Die "Wortvervollständigung" wird aufgerufen mit Strg+W. Sie zeigt alle Wörter aus allen derzeit offenen Editoren und kann deshalb auch in Nicht-Pascal-Quelltexten, in Kommentaren und für Schlüsselwörter benutzt werden.

Ansonsten funktioniert sie genau gleich wie die Bezeichner-Vervollständigung.

Zu Include-Anweisung springen

"Zu Include-Anweisung springen" im Menü 'Suchen' der IDE springt zur {$I filename} Anweisung, wo die aktuelle Include-Datei verwendet wird.

Projekt veröffentlichen

Erzeugt eine Kopie des gesamten Projekts. Wenn Sie jemandem einfach die Quellen und Kompilereinstellungen Ihres Codes senden wollen, dann ist diese Funktion Ihr Freund.

Ein normales Projektverzeichnis enthält eine Menge an Informationen. Das meiste davon wird für eine Veröffentlichung nicht benötigt: Die .lpi Datei enthält Sessioninformationen (wie Cursorposition und Lesezeichen geschlossener Units) und das Projektverzeichnis enthält eine Menge von .ppu und .o Dateien und die ausführbare Datei. Um eine .lpi Datei zu erzeugen, die nur die Basisinformationen und nur den Quellen enthält (zusammen mit allen Unterverzeichnissen), verwenden Sie "Projekt veröffentlichen".

Anmerkung: Seit Version 0.9.13 gibt es eine neue Projekteinstellung die es Ihnen erlaubt, Sessioninformationen in einer anderen Datei als der normalen .lpi Datei zu speichern. Diese neue Datei endet mit der .lps Erweiterung und enthält nur Sessioninformationen, was die .lpi Datei viel übersichtlicher macht.

In dem Dialog können Sie den Exclude- und Include-Filter einstellen, und mit dem anschließenden Kommando können Sie den Output in ein einzelnes Archiv komprimieren.

Tipps von Kommentaren

An verschiedenen Stellen zeigt die IDE Tipps für einen Bezeichner an. Beispielsweise, wenn Sie den Mauszeiger über einen Bezeichner im Quelltexteditor bewegen und einige Sekunden warten. Wenn die IDE einen Tipp für einen Bezeichner anzeigt, sucht sie die Deklaration und alle ihre Vorfahren und hält nach Kommentaren und fpdoc-Dateien Ausschau. Es gibt viele Kodierstile und viele Kommentierstile. Um möglichst viele der allgemein üblichen Stile zu unterstützen, benutzt die IDE folgende Heuristik:

Kommentare im Tipp angezeigt

Kommentare vor einer Deklaration, ohne Leerzeile und nicht mit dem <-Zeichen beginnend:

var
  {Comment}
  Identifier: integer;

Kommentare mit dem <-Zeichen gehören zum vorhergehenden Bezeichner.

Kommentare hinter einem Bezeichner in der selben Zeile:

var 
  identifier, // Comment
  other,

Kommentare hinter der Definition in der selben Zeile:

var
  identifier: 
    char; // Comment

Ein Beispiel für das <-Zeichen:

const
  a = 1;
  //< comment for a
  b = 2;
  // comment for c
  c = 3;

Alle drei Kommentartypen werden unterstützt:

  {Comment}(*Comment*)//Comment
  c = 1;

Kommentare, die mit $ und % beginnen, werden ignoriert.

Kommentare, nicht im Tipp angezeigt

Vorlaufende Kommentare, die mit einer Leerzeile abgetrennt werden, werden als unspezifisch für den folgenden Bezeichner angesehen. Beispielsweise wird der Kommentar für den folgenden Klassenheader nicht im Tipp angezeigt:

type
  { TMyClass }
  
  TMyClass = class

Die Kommentare für Klassenheader werden bei der Klassenvervollständigung erzeugt. Sie können dies ausschalten unter Einstellungen / Codetools / Klassenvervollständigung / Header-Kommentar für die Klasse. Falls Sie den Header-Kommentar im Tipp anzeigen wollen, entfernen Sie einfach die Leerzeile.

Der folgende Kommentar wird angezeigt für GL_TRUE, aber nicht für GL_FALSE:

  // Boolean
  GL_TRUE                           = 1;
  GL_FALSE                          = 0;