Difference between revisions of "Lazarus IDE Tools/de"

From Lazarus wiki
Jump to navigationJump to search
m
m (→‎Code-Schablonen: findet sich unter Werkzeuge -> Vorlagen)
 
(48 intermediate revisions by 12 users not shown)
Line 2: Line 2:
  
 
== Überblick ==
 
== Überblick ==
Die [[Glossary#IDE|IDE]] verwendet eine Bibliothek von pascal source parsing and editing tools, genannt die "CodeTools". Diese Werkzeuge bieten Features wie find declaration, Codevervollständigung, extraction, moving inserting und beautifying pascal sources. Diese Funktionen sparen ihnen eine Menge Zeit und doppelte Arbeit. Sie sind anpassbar und jedes Feature ist verfügbar mittels Tastenkombinationen (siehe Editoreinstellungen).
+
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 an den Quellen arbeiten und FPC, [[Glossary#Delphi|Delphi]] und [[Glossary#Kylix|Kylix]] Code verstehen, benötigen sie keine kompilierten Units oder einen installierten Borland Compiler. Sie können Delphi und FPC Code zur selben 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.
+
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 ==
+
== Übersichtstabelle der IDE-Tastenkombinationen ==
 
{|
 
{|
 
|-
 
|-
| Declaration Jumping || Ctrl+Click (springt zur Deklaration eines type oder Variablen)
+
| [[Lazarus_IDE_Tools/de#Find Declaration|Declaration Jumping]] || {{keypress|Strg}}+Klick (springt zur Deklaration eines Typs oder einer Variablen)
 
|-
 
|-
| Method Jumping || Ctrl+Shift+Up (schaltet zwischen Definition und Rumpf um)
+
| [[Lazarus_IDE_Tools/de#Methodenspringen|Methodenspringen]] || {{keypress|Strg}}+{{keypress|Shift}}+{{keypress|Up}} (schaltet zwischen Definition und Rumpf einer Prozedur/Methode um)
 
|-
 
|-
| Code-Schablonen || Ctrl+J
+
| [[Lazarus_IDE_Tools/de#Code-Schablonen|Code-Schablonen]] || {{keypress|Strg}}+{{keypress|J}}
 
|-
 
|-
| Codevervollständigung (Class Completion)   || Ctrl+Shift+C
+
| [[Lazarus_IDE_Tools/de#Synchronbearbeitung|Synchronbearbeitung]] || {{keypress|Strg}}+{{keypress|J}} (bei ausgewähltem Text)
 
|-
 
|-
| Bezeichnervervollständigung || Ctrl+Space
+
| [[Lazarus_IDE_Tools/de#Codevervollständigung|Codevervollständigung]] (Klassenvervollständigung) || {{keypress|Strg}}+{{keypress|Shift}}+{{keypress|C}}
 
|-
 
|-
| Word Completion || Ctrl+W
+
| [[Lazarus_IDE_Tools/de#Bezeichner-Vervollständigung|Bezeichner-Vervollständigung]] || {{keypress|Strg}}+{{keypress|Space}}
 +
|-
 +
| [[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#Inkrementelle Suche|Inkrementelle Suche]] || {{keypress|Strg}}+{{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 Prozedurendefinition (procedure Name;) zu springen verwenden sie Ctrl+Shift+Up.
+
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; // Prozedurendefinition
+
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 Ctrl+Shift+Up drücken, dann wird der Cursor zur Definition springen. Erneutes Drücken von Ctrl+Shift+Up 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'.
  
 
Dies funktioniert ebenfalls zwischen Methoden (Prozeduren in Klassen).
 
Dies funktioniert ebenfalls zwischen Methoden (Prozeduren in Klassen).
  
 
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 Cursor 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 Cursor auf dem 'string' Schlüsselwort positionieren. Dies kann verwendet werden für das Umbenennen von Methoden und/oder dem Ä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 die Prozedur umbenannt haben gibt es exakt einen Rumpf ohne Definition (DoSomething) und daher wird sie zu DoSomething springen und den Cursor rechts neben 'DoSomething' positionieren. Dann können sie es dort auch unbenennen. Das funktioniert für Parameter ebenfalls.
+
 
 +
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 ==
Include Dateien sind Dateien, die mit der ($I filename) oder ($INCLUDE filename) Compiler Direktive in die Quellen eingefügt werden. Lazarus und FPC verwenden eine Menge von diesen Dingen um Redundanz zu reduzieren und unlesbare ($IFDEF) Konstrukte zu vermeiden um verschiedene Plattformen zu unterstützen.
+
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.
+
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:
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 [[Glossary#Unit|Unit]] zuerst öffnen.
+
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 analysieren und die IDE wird sich an diese Beziehung erinnern. Sie wird diese Informationen beim Beenden speichern und on project save to ~/.lazarus/includelinks.xml. Wenn sie das nächste Mal diese Include-Datei öffnen und jump or do a find declaration, the IDE will internally open the unit and the jump will work.
+
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
 +
<syntaxhighlight lang=pascal>{%mainunit yourunit.pas}</syntaxhighlight>
 +
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.
 
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. ;)
+
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==
 
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 Ctrl+J. Sie können einen Bezeichner eintippen, Ctrl+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', hinterlassen den Cursor rechts hinter dem 'f' und drücken Ctrl+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 Cursor an eine freie Stelle positionieren (nicht auf einem Bezeichner) und Ctrl+J drücken. Die Liste der Code-Schablonen wird auftauchen. Verwenden sie die Cursortasten oder tippen einige Buchstaben um eine auszuwählen. Return erzeugt die gewählte Vorlage und Escape schließt das pop up.
+
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.
 +
 
 +
Die größten Zeitsparer sind die Schablonen 'b'+{{keypress|Strg}}+{{keypress|J}} für begin..end.
 +
 
 +
== Parameter-Hinweise ==
 +
 
 +
Parameter-Hinweise zeigen eine Hinweisbox mit den Parameter-Deklarationen für die aktuelle Parameterliste.
 +
 
 +
Zum Beispiel
 +
 
 +
<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.
 +
 
 +
[[Image: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.
 +
 
 +
[[Image:Parameterhints2.png]]
 +
 
 +
Tipp: Benutzen Sie die [[#Variable Declaration Completion|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 {{keypress|Strg}}+{{keypress|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 '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}}.
 +
*{{keypress|Backspace}} entfernt das letzte Zeichen
 +
*{{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.
 +
*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).
 +
 
 +
=== 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 {{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|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 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 {{keypress|Strg}}+{{keypress|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 {{keypress|Tab}}-Taste, um das zu bearbeitende Wort auszuwählen (wenn einige verschiedene Wörter mehrfach auftreten).
 +
* Bearbeiten Sie das Wort.
 +
* Drücken Sie {{keypress|Esc}} zum Beenden
 +
 
 +
Sehen Sie sich [[New_IDE_features_since#Syncron-Edit|hier]] ein animiertes Beispiel an.
 +
 
 +
* Anmerkung: {{keypress|Strg}}+{{keypress|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 ==
 
== Codevervollständigung ==
''Codevervollständigung'' ist zu finden im IDE Menü Bearbeiten -> Quelltext vervollständigen und hat als standard short cut Ctrl+Shift+C.
+
Die Codevervollständigung ist im IDE-Menü zu finden unter Bearbeiten -> Quelltext vervollständigen und hat das Standardkürzel {{keypress|Strg|Shift|C}}.  
  
 
Für Delphianer:
 
Für Delphianer:
Delphi bezeichnet mit ''Codevervollständigung'' die Funktion, welche die Liste der Bezeichner an der aktuellen Quellenposition zeigt (Ctrl+Space). Unter Lazarus wird dies ''Bezeichnervervollständigung'' genannt.
+
Delphi bezeichnet mit "Codevervollständigung" die Funktion, die die Liste der Bezeichner an der aktuellen Quellenposition zeigt ({{keypress|Strg|Leertaste}}). Unter Lazarus wird dies ''Bezeichnervervollständigung'' genannt.
  
 
''Codevervollständigung'' kombiniert verschiedene mächtige Funktionen. Beispiele:
 
''Codevervollständigung'' kombiniert verschiedene mächtige Funktionen. Beispiele:
* Class Completion: komplettiert Eigenschaften, fügt Methodenrümpfe hinzu, add private variables and private access methods
+
* [[#Class Completion|Class Completion]]: komplettiert Eigenschaften; fügt Methodenrümpfe, private Variablen und private Zugriffsmethoden hinzu
* Forward Procedure Completion: fügt Prozedurenrümpfe hinzu
+
* [[#Forward Procedure Completion|Forward Procedure Completion]]: fügt Prozedurenrümpfe hinzu
* Event Assignment Completion: completes event assignments and adds method definition and body
+
* [[#Event Assignment Completion|Event Assignment Completion]]: komplettiert Ereigniszuweisungen; fügt Methodendefinition und -rumpf hinzu
* Variable Declaration Completion: fügt lokale Variablendefinitionen hinzu  
+
* [[#Variable Declaration Completion|Variable Declaration Completion]]: fügt lokale Variablendefinitionen hinzu  
 +
* [[#Reversed Class Completion|Reversed Class Completion]]: fügt Methoden-Deklarationen für Methodenrümpfe hinzu
 +
* [[#Procedure Call Completion|Procedure Call Completion]]: fügt eine neue Prozedur hinzu
 +
* [[#Reversed Procedure Completion|Reversed procedure completion]]: fügt Deklarationen für Prozedur-/Funktionsrümpfe hinzu
 +
 
 +
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 {{keypress|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):
 +
 
 +
<syntaxhighlight lang=pascal>TExample = class(TObject)
 +
public
 +
  constructor Create;
 +
  destructor Destroy; override;
 +
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:
  
Welche Funktion genutzt wird, hängt von der Cursorposition im Editor ab.
+
<syntaxhighlight lang=pascal>{ TExample }
  
=== Class Completion ===
+
constructor TExample.Create;
 +
begin
 +
  |
 +
end;
  
Das mächtigste ''Codevervollständigung'' 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 Eigenschaftszugriff Methoden/Variablen und die private Variablen.
+
destructor TExample.Destroy;
 +
begin
 +
  inherited Destroy;
 +
end;</syntaxhighlight>
  
Zum Beispiel: Erzeugen sie eine Klasse (siehe Code-Schablonen um einige Tipparbeit zu sparen):  
+
Anmerkung: Das '|' ist der Kursor und nicht hinzugefügt.
  
TExample = class(TObject)
+
Hinweis: Sie können zwischen einer Methode und ihrem Rumpf springen mit {{keypress|Strg|Shift|Nach oben}}.  
public
 
  constructor Create;
 
  destructor Destroy; override;
 
end;
 
Positionieren sie den Cursor irgendwo in der Klasse und drücken Ctrl+Shift+C. Dies wird die fehlenden Methodenrümpfe erzeugen und den Cursor zu dem ersten erzeugten Methodenrumpf bewegen, so daß sie jetzt mit dem Schreiben des class Codes beginnen können:
 
  
{ TExample }
+
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.  
 
constructor TExample.Create;
 
begin
 
  |
 
end;
 
 
destructor TExample.Destroy;
 
begin
 
  inherited Destroy;
 
end;
 
Anmerkung: Das '|' ist der Cursor und nicht hinzugefügt.  
 
  
Hinweis: Sie können zwischen einer Methode und ihrem Rumpf springen mit Ctrl+Shift+Up.
+
Jetzt fügen Sie eine Methode DoSomething hinzu:
  
Sie können sehen, daß die IDE auch den 'inherited Destroy' Aufruf hinzugefügt hat. Dies wird getan, wenn es ein 'override' Schlüsselwort in der ''class'' Definition gibt.
+
<syntaxhighlight lang=pascal>TExample = class(TObject)
 +
public
 +
  constructor Create;
 +
  procedure DoSomething(i: integer);
 +
  destructor Destroy; override;
 +
end;</syntaxhighlight>
  
Jetzt fügen sie eine Methode DoSomething hinzu:  
+
Dann drücken Sie {{keypress|Strg|Shift|C}} und die IDE wird hinzufügen:  
  
TExample = class(TObject)
+
<syntaxhighlight lang=pascal>procedure TExample.DoSomething(i: integer);
public
+
begin
  constructor Create;
+
  |
  procedure DoSomething(i: integer);
+
end;</syntaxhighlight>
  destructor Destroy; override;
 
end;
 
Dann drücken sie Ctrl+Shift+C und die IDE wird hinzufügen
 
  
procedure TExample.DoSomething(i: integer);
+
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.  
begin
 
  |
 
end;
 
Sie können sehen, daß der neue Methodenrumpf eingefügt wurde zwischen Create und Destroy, exakt wie in der ''class'' Definition. This way the bodies keep the same logical ordering as you define. You can define the insertion policy 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 Ctrl+Shift+C und sie werden 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;
Die ''Codevervollständigung'' hat added a Write access modifier and added some common code.
+
end;</syntaxhighlight>
Jump to the class with Ctrl+Shift+Up um die neue class zu sehen:
+
 
TExample = class(TObject)
+
Die Codevervollständigung hat den Schreibzugriff geändert und den üblichen Code ergänzt.
private
+
Springen Sie mit {{keypress|Strg|Shift|Nach oben}} zur Klasse, um die neue Klasse ganz zu sehen:
  FAnInteger: integer;
+
<syntaxhighlight lang=pascal>TExample = class(TObject)
  procedure SetAnInteger(const AValue: integer);
+
private
public
+
  FAnInteger: integer;
  constructor Create;
+
  procedure SetAnInteger(const AValue: integer);
  procedure DoSomething(i: integer);
+
public
  destructor Destroy; override;
+
  constructor Create;
  property AnInteger: integer read FAnInteger write SetAnInteger;
+
  procedure DoSomething(i: integer);
end;
+
  destructor Destroy; override;
The property was extended by a Read and Write access modifier. The class got the new section 'private' with a Variable 'FAnInteger' and the method 'SetAnInteger'.
+
  property AnInteger: integer read FAnInteger write SetAnInteger;
It is a common Delphi style rule to prepend private variables with an 'F' and the write method with a 'Set'. Wenn sie das nicht mögen, dann können sie es ändern unter Einstellungen -> Codetools Einstellungen -> Quelltexterzeugung.
+
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'.
 +
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.
  
Creating a read only property:
+
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>
Creating a write only property:
+
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>
Creating a read only property with a Read method:
+
Erzeugen einer Eigenschaft 'read only' mit einer Read-Methode:
property PropName: PropType read GetPropName;
+
<syntaxhighlight lang=pascal>property PropName: PropType read GetPropName;</syntaxhighlight>
Will be kept and a GetPropName function will be added:
+
wird beibehalten und eine Funktion 'GetPropName' wird angefügt:
function GetpropName: PropType;
+
<syntaxhighlight lang=pascal>function GetpropName: PropType;</syntaxhighlight>
Creating a property with a stored modifier:
+
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>
Because stored is used for streaming read and write modifiers are automatically added as well.
+
Weil 'stored' für das Streaming benutzt wird, werden automatisch auch die read- und write-Modifizierer angefügt.
  
 
Hinweis:
 
Hinweis:
''Bezeichnervervollständigung'' also recognizes incomplete properties and will suggest the default names. 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 Cursor eine Leerstelle hinter dem 'read' Schlüsselwort und drücken Ctrl+Space für die ''Bezeichnervervollständigung''. It will present you the variable 'FPropName' and the procedure 'SetPropName'.
+
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 ===
+
===Forward Procedure Completion===
''Forward Procedure Completion'' ist ein Teil der ''Codevervollständigung'' und fügt fehlende Prozedurrümpfe hinzu. Es wird aufgerufen, wenn der Cursor auf einer vorwärts definierten Prozedur ist.
+
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:
 
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 Cursor darauf und drücken Ctrl+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 Ctrl+Shift+Up.
+
 
 +
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:
 +
<syntaxhighlight lang=pascal>procedure Proc1;
 +
procedure Proc2; // neue Prozedur
 +
procedure Proc3;</syntaxhighlight>
  
Der neue Prozedurrumpf wird vor den class Methoden 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.
 
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>
Code Completion wird alle 3 Prozedurrümpfe hinzufügen (Proc2_New, Proc3_New, Proc4_New).
 
  
Warum wird es ''Forward Procedure Completion'' genannt?
+
Die Codevervollständigung wird alle 3 Prozedurrümpfe hinzufügen (Proc2_New, Proc3_New, Proc4_New).
  
Weil es nicht nur für Prozeduren funktioniert, die im interface definiert sind, sondern auch für Prozeduren mit dem "forward" Bezeichner.
+
Warum wird das ''Forward Procedure Completion'' genannt?
  
=== Event Assignment Completion ===
+
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'' ist ein Teil der ''Codevervollständigung'' und komplettiert eine einzelne Ereignis:=| Anweisung. Es wird aufgerufen, wenn der Cursor hinter an assignment to einem Ereignis ist.
+
 
 +
===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:
 
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 Cursor und sollte nicht eingegeben werden.
+
 
Dann drücken sie Ctrl+Shift+C für die ''Codevervollständigung''. Die Anweisung wird komplettiert zu
+
Das '|' ist der Kursor und sollte nicht eingegeben werden.
OnPaint:=@Form1Paint;
+
Dann drücken sie Strg+Shift+C für die ''Codevervollständigung''. Die Anweisung wird komplettiert zu
Eine neue Methode Form1Paint wird zur TForm1 class hinzugefügt. Dann wird ''class completion'' gestartet und sie erhalten:
+
<syntaxhighlight lang=pascal>OnPaint:=@Form1Paint;</syntaxhighlight>
procedure TForm1.Form1Paint(Sender: TObject);
+
Eine neue Methode Form1Paint wird zur Klasse TForm1 hinzugefügt. Dann wird die ''class completion'' gestartet und Sie erhalten:
begin
+
<syntaxhighlight lang=pascal>procedure TForm1.Form1Paint(Sender: TObject);
  |
+
begin
end;
+
  |
 +
end;</syntaxhighlight>
 
Das funktioniert wie das Hinzufügen von Methoden im Objektinspektor.
 
Das funktioniert wie das Hinzufügen von Methoden im Objektinspektor.
  
 
Anmerkung:<br>
 
Anmerkung:<br>
Sie müssen den Cursor hinter dem ':=' assignment operator platzieren. Wenn sie den Cursor auf dem Bezeichner platzieren (z.B. OnPaint) wird ''Codevervollständigung'' "Local Variable Completion" aufrufen, welches fehlschlägt, weil OnPaint bereits definiert ist.
+
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:<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===
''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 Cursor auf dem Bezeichner auf einer Zuweisung oder einem Parameter ist.
+
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:
 
Zum Beispiel:
procedure TForm1.Form1Create(Sender: TObject);
+
<syntaxhighlight lang=pascal>procedure TForm1.Form1Create(Sender: TObject);
begin
+
begin
  i:=3;
+
  i:=3;
end;
+
end;</syntaxhighlight>
Platzieren sie den Cursor auf dem 'i' oder genau dahinter. Dann drücken sie Ctrl+Shift+C für die ''Codevervollständigung'' und sie werden 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:
procedure TForm1.Form1Create(Sender: TObject);
+
<syntaxhighlight lang=pascal>procedure TForm1.Form1Create(Sender: TObject);
var
+
var
  i: Integer;
+
  i: Integer;
begin
+
begin
  i:=3;
+
  i:=3;
end;
+
end;</syntaxhighlight>
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 Abgrenzungs ':=' Operators. 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:
type
+
<syntaxhighlight lang=pascal>type
 
   TWhere = (Behind, Middle, InFront);
 
   TWhere = (Behind, Middle, InFront);
 
   
 
   
Line 296: 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>
Platzieren sie den Cursor auf 'Where' und drücken Ctrl+Shift+C für die ''Codevervollständigung''. Sie erhalten:
+
 
  procedure TForm1.Form1Create(Sender: TObject);
+
Platzieren Sie den Kursor auf 'Where' und drücken Sie {{keypress|Strg|Shift|C}} für die Codevervollständigung. Sie erhalten:
 +
<syntaxhighlight lang=pascal>  procedure TForm1.Form1Create(Sender: TObject);
 
   var
 
   var
 
     a: array[TWhere] of char;
 
     a: array[TWhere] of char;
Line 304: 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>
  
 
Seit Version 0.9.11 komplettiert Lazarus auch Parameter. Zum Beispiel
 
Seit Version 0.9.11 komplettiert Lazarus auch Parameter. Zum Beispiel
  procedure TForm1.FormPaint(Sender: TObject);
+
<syntaxhighlight lang=pascal>  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>
Platzieren sie den Cursor auf 'x1' und drücken Ctrl+Shift+C für die ''Codevervollständigung''. Sie erhalten:
+
 
  procedure TForm1.FormPaint(Sender: TObject);
+
Platzieren Sie den Kursor auf 'x1' und drücken Sie {{keypress|Strg|Shift|C}} für die Codevervollständigung. Sie erhalten:
 +
<syntaxhighlight lang=pascal>  procedure TForm1.FormPaint(Sender: TObject);
 
   var
 
   var
 
     x1: integer;
 
     x1: integer;
Line 321: Line 421:
 
       Line(x1,y1,x2,y2);
 
       Line(x1,y1,x2,y2);
 
     end;
 
     end;
   end;
+
   end;</syntaxhighlight>
 +
 
 +
===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
 +
<syntaxhighlight lang=pascal>procedure SomeProcedure;
 +
var
 +
  Width: integer;
 +
begin
 +
  Width:=3;
 +
  DoSomething(Width);
 +
end;</syntaxhighlight>
 +
 
 +
Platzieren Sie den Kursor über dem Bezeichner "DoSomething" und drücken Sie {{keypress|Strg|Shift|C}}. Sie erhalten:
 +
 
 +
<syntaxhighlight lang=pascal>procedure DoSomething(aWidth: LongInt);
 +
begin
 +
 
 +
end;
 +
 
 +
procedure SomeProcedure;
 +
var
 +
  Width: integer;
 +
begin
 +
  Width:=3;
 +
  DoSomething(Width);
 +
end;</syntaxhighlight>
 +
 
 +
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:
 +
<syntaxhighlight lang=pascal>  procedure TForm1.DoSomething(Sender: TObject);
 +
  begin
 +
  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.
 +
 
 +
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 ===
+
===Kommentare und Codevervollständigung===
''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, starting
+
     Dies ist ein Kommentar über mehrere Zeilen, beginnend
     in the FList line, so codetools assumes it belongs
+
     in der FList-Zeile. Die CodeTools nehmen an, er gehöre
     to the FLIst line and will not break this
+
     zu der FList-Zeile und brechen diese Beziehung nicht
     relationship. Code is inserted behind the comment. }
+
     auf. Der Code wird hinter dem Kommentar eingefügt. }
   FInt: integer;
+
   FInt: integer;</syntaxhighlight>
Wenn der Kommentar in der nächsten Zeile startet:
+
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
     { This comment belongs to the statement below.  
+
     { Dieser Kommentar gehört zur nachfolgenden Anweisung.  
       New code is inserted above this comment and
+
       Neuer Code wird oberhalb des Kommentars eingefügt und
       behind the comment of the FList line. }
+
       hinter dem Kommentar der FList-Zeile. }
   FInt: integer;
+
   FInt: integer;</syntaxhighlight>
 +
 
 +
===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''.
 +
<syntaxhighlight lang=pascal>  public
 +
    procedure DoSomething;
 +
  end;
 +
 
 +
procedure TForm.DoSomething;
 +
begin
 +
end;</syntaxhighlight>
 +
 
 +
Fügen Sie jetzt einen Parameter hinzu:
 +
 
 +
<syntaxhighlight lang=pascal>  public
 +
    procedure DoSomething(i: integer);
 +
  end;</syntaxhighlight>
 +
 
 +
und rufen Sie die Codevervollständigung auf mit ({{keypress|Strg|Shift|C}}). Der Methodenrumpf wird aktualisiert und der neue Parameter wird kopiert:
  
== Refactoring ==
+
<syntaxhighlight lang=pascal>procedure TForm.DoSomething(i: integer);
 +
begin
 +
end;</syntaxhighlight>
  
=== Invert Assignments ===
+
==Refactoring==
  
;Abstract: : "Invert Assignments" takes some selected pascal statements and inverts all assignments from this code. This tool is usefull for transforming a "save" code to a "load" one and inverse operation.
+
===Invert Assignments===
  
Example:<br>
+
;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.
procedure DoSomething;
 
begin
 
  AValueStudio:= BValueStudio;
 
  AValueAppartment :=BValueAppartment;
 
  AValueHouse:=BValueHouse;
 
end;
 
Select the lines with assignments (between begin and end) and do Invert Assignments. All assignments will be inverted and identation will be add automatically. For example:
 
  
Result:
+
Beispiel:<br>
procedure DoSomething;
+
<syntaxhighlight lang=pascal>procedure DoSomething;
begin
+
begin
  BValueStudio    := AValueStudio;
+
  AValueStudio:= BValueStudio;
  BValueAppartment := AValueAppartment;
+
  AValueAppartment :=BValueAppartment;
  BValueHouse      := AValueHouse;
+
  AValueHouse:=BValueHouse;
end;
+
end;</syntaxhighlight>
  
=== Extract Procedure ===
+
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:
;Kurz gefasst: : "Extract Procedure" nimmt die ausgewählten Pascal Anweisungen und erstellt eine neue Prozedur/Methode aus diesem Code. Dieses Werkzeug ist hilfreich um große Prozeduren aufzusplitten oder um eine neue Prozedur einfach aus dem Code zu erstellen.
 
  
Ein einfaches Beispiel:<br>
+
Resultat:
procedure DoSomething;
+
<syntaxhighlight lang=pascal>procedure DoSomething;
begin
+
begin
  CallSomething;
+
  BValueStudio    := AValueStudio;
end;
+
  BValueAppartment := AValueAppartment;
Markieren sie die Zeile "CallSomething;" und führen Extract Proc aus. Ein Dialog taucht auf und
+
  BValueHouse      := AValueHouse;
sie können den Typ und Namen der zu erstellenden Prozedur wählen. Zum Beispiel:
+
end;</syntaxhighlight>
procedure, "NewProc". Result:
+
 
procedure NewProc;
+
=== Enclose Selection ===
begin
+
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.
  CallSomething;
+
 
end;
+
===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.
procedure DoSomething;
+
* 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.
begin
+
* Und es wird zuerst auf Namenskonflikte überprüft.
  NewProc;
+
* Beschränkungen: Das funktioniert nur mit Pascal-Quellen, benennt keine Dateinamen um und bearbeitet weder lfm/lrs-Dateien noch lazdoc-Dateien.
end;
 
Sie können sehen, daß die neue Prozedur "NewProc" erzeugt wurde mit the selection
 
as body und der alte Code durch einen Aufruf ersetzt wurde.
 
  
Lokale Variablen und Parameter:<br>
+
===Find Identifier References===
"Extract Proc" scans for used variables and automatically creates the
+
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.
parameter list and local variables. Example:
 
procedure TForm1.DoSomething(var Erni, Bert: integer);
 
var
 
  i: Integer; // Comment
 
begin
 
  Erni:=Erni+Bert;
 
  for i:=Erni to 5 do begin
 
  |
 
  end;
 
end;
 
Select the for loop and create a new Procedure "NewProc". The local variable i is only used in the selection, so it will be moved to the new procedure. Erni is also used in the remaining code, so it will become a parameter.
 
  
Result:<br>
+
=== Show abstract methods ===
procedure NewProc(const Erni: integer);
+
Dieses Merkmal listet und ergänzt automatisch virtuelle, abstrakte Methoden, die noch implementiert werden müssen.
var
+
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.
  i: Integer; // Comment
 
begin
 
  for i:=Erni to 5 do begin
 
  |
 
  end;
 
end;
 
 
procedure TForm1.DoSomething(var Erni, Bert: integer);
 
begin
 
  Erni:=Erni+Bert;
 
  NewProc(Erni);
 
end;
 
  
You can see "i" was moved to the new procedure (Note: including its comment) and Erni.
+
===Prozedur extrahieren===
  
Limitations:<br>
+
Siehe [[IDE_Window:_Extract_Procedure|Prozedur extrahieren]]
Pascal ist eine sehr mächtige Sprache. Erwarten sie daher nicht, daß es mit jedem Code funktioniert. Aktuelle Limits/ToDos:
 
* check if selection bounds on statement bounds
 
* "with" statements
 
  
== Find Declaration ==
+
==Find Declaration==
Positionieren sie den Cursor auf einem Bezeichner und starten ''Find Declaration''. Das wird die Deklaration dieses Bezeichners suchen, die Datei öffnen und zu ihr springen.
+
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.
+
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:
 
Es gibt einige Unterschiede zu Delphi:
Die ''CodeTools'' arbeiten mit den Quellen, den normalen Pascal Regeln folgend, anstelle der Verwendung des Compiler output. Der Compiler liefert den finalen Typ zurück. Die ''CodeTools'' sehen die Quellen und alle Schritte dazwischen. Zum Beispiel:
+
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.
+
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 erneut um zu Visible in TControl zu springen.
+
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.
 
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 jeden overload finden.
+
Auf diese Weise können Sie jeden Bezeichner aufspüren und jede Überladung finden.
 +
 
 +
'''Tipps:'''
 +
* Sie können zurück springen mit {{keypress|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:  [[IDE_Window:_EditorMouseOptionsAdvanced#Change_History_Jumps_for_3_button_Mouse_.28follow_back_the_.22Source_Link.22_trail.29|advanced mouse options]])
  
== Goto Include Directive ==
+
==Bezeichner-Vervollständigung==
"Zu Include Direktive springen" im Suche Menü der IDE springt zur {$I filename} Anweisung, wo die aktuelle include Datei verwendet wird.
+
Die "Bezeichner-Vervollständigung" wird aufgerufen mittels {{keypress|Strg|space}}. Sie zeigt alle Bezeichner im Suchbereich. Zum Beipiel:
  
== Projekt veröffentlichen ==
+
<syntaxhighlight lang=pascal>procedure TForm1.FormCreate(Sender: TObject);
Erzeugt eine Kopie des gesamten Projekts. Wenn sie jemandem einfach die Quellen und Kompilereinstellungen ihres Codes senden wollen, dann ist dies Funktion ihr Freund.
+
begin
 +
  |
 +
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.
 +
 
 +
'''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 {{keypress|Strg|W}} [[#Word Completion|Wortvervollstandigung]] oder {{keypress|Strg|J}} [[#Code Templates|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:
 +
 
 +
<syntaxhighlight lang=pascal>procedure TForm1.FormCreate(Sender: TObject);
 +
begin
 +
  Ca|ption
 +
end;</syntaxhighlight>
 +
 
 +
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:
 +
 
 +
<syntaxhighlight lang=pascal>TMainForm = class(TForm)
 +
protected
 +
  mous|
 +
end;</syntaxhighlight>
 +
 
 +
Die Vervollständigung von '''MouseDown''' ergibt:
 +
 
 +
<syntaxhighlight lang=pascal>TMainForm = class(TForm)
 +
protected
 +
  procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X,
 +
        Y: Integer); override;
 +
end;</syntaxhighlight>
 +
 
 +
===Eigenschaften===
 +
 
 +
<syntaxhighlight lang=pascal>property MyInt: integer read |;</syntaxhighlight>
 +
 
 +
Die Bezeichner-Vervollständigung zeigt Ihnen '''FMyInt''' und '''GetMyInt'''.
 +
 
 +
<syntaxhighlight lang=pascal>property MyInt: integer write |;</syntaxhighlight>
 +
 
 +
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===
 +
 
 +
<syntaxhighlight lang=pascal>procedure TMainForm.Button1Click(Sender: TObject);
 +
begin
 +
  ModalRe|;
 +
end;</syntaxhighlight>
 +
 
 +
wird zu:
 +
 
 +
<syntaxhighlight lang=pascal>procedure TMainForm.Button1Click(Sender: TObject);
 +
begin
 +
  ModalResult:=|;
 +
end;</syntaxhighlight>
 +
 
 +
==Wortvervollständigung==
 +
Die "Wortvervollständigung" wird aufgerufen mit {{keypress|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:
 
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 das executable.
+
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 nur mit den Basisinformationen und nur den Quellen, zusammen mit allen Unterverteichnissen verwenden sie "Projekt veröffentlichen".
+
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:
 +
 
 +
<syntaxhighlight lang=pascal>var
 +
  {Comment}
 +
  Identifier: integer;</syntaxhighlight>
 +
 
 +
Kommentare mit dem '''<'''-Zeichen gehören zum vorhergehenden Bezeichner.
 +
 
 +
Kommentare hinter einem Bezeichner in der selben Zeile:
 +
 
 +
<syntaxhighlight lang=pascal>var
 +
  identifier, // Comment
 +
  other,</syntaxhighlight>
 +
 
 +
Kommentare hinter der Definition in der selben Zeile:
 +
 
 +
<syntaxhighlight lang=pascal>var
 +
  identifier:
 +
    char; // Comment</syntaxhighlight>
 +
 
 +
Ein Beispiel für das '''<'''-Zeichen:
 +
 
 +
<syntaxhighlight lang=pascal>const
 +
  a = 1;
 +
  //< comment for a
 +
  b = 2;
 +
  // comment for c
 +
  c = 3;</syntaxhighlight>
 +
 
 +
Alle drei Kommentartypen werden unterstützt:
 +
<syntaxhighlight lang=pascal>  {Comment}(*Comment*)//Comment
 +
  c = 1;</syntaxhighlight>
 +
 
 +
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:
 +
 
 +
<syntaxhighlight lang=pascal>type
 +
  { TMyClass }
 +
 
 +
  TMyClass = class</syntaxhighlight>
  
'''Anmerkung''': Seit Version 0.9.13 gibt es eine neue ''Projekteinstellung'' die 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.
+
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.
  
In dem Dialog können sie den exclude und include Filter einstellen, und mit dem Kommando danach können sie den Output in ein Archiv komprimieren.
+
Der folgende Kommentar wird angezeigt für GL_TRUE, aber nicht für GL_FALSE:
  
== Ursprüngliche Mitwirkende ==
+
<syntaxhighlight lang=pascal>  // Boolean
Diese Seite wurde von der epikwiki [http://lazarus-ccr.sourceforge.net/index.php?wiki=LazarusIdeTools Version] konvertiert.
+
  GL_TRUE                          = 1;
* Seite und anfängliche Vorlage erstellt - 4/6/2004 [[User:Tom Lisjac| VlxAdmin]]
+
  GL_FALSE                          = 0;</syntaxhighlight>
* Anfangsinhalt eingestellt - 4/10/2004 MattiasG
 
* Kleine Wiki- und Formatierungs-Berichtigungen - 4/11/2004 [[User:Tom Lisjac| VlxAdmin]]
 
* Ergebnistabelle für IDETools shortcuts hinzugefügt - 12 July 2004 [[User:Kirkpatc]]
 

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;