Lazarus IDE Tools/de

│ 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)
Method Jumping	Strg + ⇧ Shift + ↑ (schaltet zwischen Definition und Rumpf einer Prozedur/Methode um)
Code-Schablonen	Strg + J
Synchronbearbeitung	Strg+J (bei ausgewähltem Text)
Quelltextvervollständigung (Class Completion)	Strg + ⇧ Shift + C
Bezeichnervervollständigung	Strg + Space
Wortvervollständigung	Strg + W
Parameter-Hinweise	Strg + ⇧ Shift + Space
Inkrementelle Suche	Strg + E
Bezeichner umbenennen	Strg+⇧ Shift+E

Method Jumping

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: 'Method Jumping' springt zur selben Prozedur mit dem selben Namen und Parameterliste. Wenn es keine bestimmte Prozedur gibt, springt es zum besten Kandidaten und positioniert den Kursor auf dem ersten Unterschied. (Für Delphianer: Delphi kann dies nicht tun).

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 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.

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 Einstellungen -> Code-Schablonen.

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.

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.

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 e, sucht und markiert alle Fundstellen von 'e'.
• Dann drücken Sie t und alle Fundstellen von 'et' sind markiert usw.
• Sie springen zur nächsten Fundstelle mit F3 (oder Strg+e während der Suche) und zur vorigen Fundstelle mit {keypress|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 SieStrg+E - startet die inkrementelle Suche
• Drücken SieStrg+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:

• Class Completion: komplettiert Eigenschaften; fügt Methodenrümpfe, private Variablen und private Zugriffsmethoden hinzu
• Forward Procedure Completion: fügt Prozedurenrümpfe hinzu
• Event Assignment Completion: komplettiert Ereigniszuweisungen; fügt Methodendefinition und -rumpf hinzu
• Variable Declaration Completion: fügt lokale Variablendefinitionen hinzu
• Reversed Class Completion: fügt Methoden-Deklarationen für Methodenrümpfe hinzu
• Procedure Call Completion: fügt eine neue Prozedur hinzu
• 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 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 Strg+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.

Event Assignment Completion

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.

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 Cursor 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 TForm1 class hinzugefügt. Dann wird 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 Cursor hinter dem ':=' assignment operator platzieren. Wenn sie den Cursor auf dem Bezeichner platzieren (z.B. OnPaint) wird Codevervollständigung "Local Variable Completion" aufrufen, das fehlschlägt, weil OnPaint bereits definiert ist.

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

 OnPaint:=@ThePaintMethod;

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.

Zum Beispiel:

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

Platzieren sie den Cursor auf dem 'i' oder genau dahinter. Dann drücken sie Strg+Shift+C für die Codevervollständigung und sie werden 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 Abgrenzungs ':=' Operators. 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 Cursor auf 'Where' und drücken 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 Cursor auf 'x1' und drücken 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

Code completion can create a new procedure from a call statement itself.

Assume you just wrote the statement "DoSomething(Width);" <delphi> procedure SomeProcedure; var

 Width: integer;

begin

 Width:=3;
 DoSomething(Width);

end; </delphi>

Position the cursor over the identifier "DoSomething" and press Ctrl+Shift+C to get:

<delphi> procedure DoSomething(aWidth: LongInt); begin

end;

procedure SomeProcedure; var

 Width: integer;

begin

 Width:=3;
 DoSomething(Width);

end; </delphi>

It does not yet create functions nor methods.

Reversed Class Completion

"Reversed Class Completion" ist ein Teil der Codevervollständigung and adds a private method declaration for the current method body. 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: Class completion works under Lazarus always in one way: From class interface to implementation or backwards/reversed from class implementation to interface. Delphi always invokes both directions. The Delphi way has the disadvantage, that if a typo will easily create a new method stub without noticing.

Kommentare und Codevervollständigung

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, starting
   in the FList line, so codetools assumes it belongs 
   to the FLIst line and will not break this 
   relationship. Code is inserted behind the comment. }
 FInt: integer;

Wenn der Kommentar in der nächsten Zeile startet:

 FList: TList; // list of TComponent
   { This comment belongs to the statement below. 
     New code is inserted above this comment and 
     behind the comment of the FList line. }
 FInt: integer;

Refactoring

Invert Assignments

Kurz gefasst

: "Invert Assignments" takes some selected pascal statements and inverts all assignments from this code. Dieses Werkzeug ist hilfreich für das Umwandeln eines "save" Code in einen "load" Code und umgekehrt.

Beispiel:

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

Select the lines with assignments (zwischen begin und end) and do Invert Assignments. All assignments will be inverted and identation will be add automatically. Zum Beispiel:

Resultat:

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

Enclose Selection

Select some text and invoke it. A dialog will popup where you can select if the selection should be enclosed into try..finally or many other common blocks.

Rename Identifier

Place the cursor on an identifier and invoke it. A dialog will appear, where you can setup the search scope and the new name.

• It will rename all occurences and only those that actually use this declaration. That means it does not rename declarations with the same name.
• And it will first check for name conflicts.
• Limits: It only works on pascal sources, does not yet rename files nor adapt lfm/lrs files nor lazdoc files.

Find Identifier References

Place the cursor on an identifier and invoke it. A dialog will appear, where you can setup the search scope. The IDE will then search for all occurences and only those that actually use this declaration. That means it does not show other declarations with the same name.

Show abstract methods

This feature lists and auto completes virtual, abstracts methods that need to be implemented. Place the cursor on a class declaration and invoke it. If there are missing abstract methods a dialog will appear listing them. Select the methods to implement and the IDE creates the method stubs.

Prozedur extrahieren

Siehe Prozedur extrahieren

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.

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 des Compiler output. 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 erneut 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 jeden overload finden.

Identifier Completion

"Identifier Completion" is invoked by Strg+Space. It shows all identifiers in scope. For example:

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

Place the cursor between begin and end and press Strg+Space. The IDE/CodeTools will now parse all reachable code and present you a list of all found identifiers. The CodeTools cache the results, so invoking it a second time will be much faster.

Note for Delphians: Delphi calls it Code completion.

Some identifiers like 'Write', 'ReadLn', 'Low', 'SetLength', 'Self', 'Result', 'Copy' are built into the compiler and are not defined anywhere in source. The identifier completion has a lot of these things built in as well. If you find one missing, just create a feature request in the bug tracker.

Identifier completion does not complete all keywords. So you can not use it to complete 'repe' to 'repeat'. For these things use Strg+W Word Completion or Strg+J Code Templates. Since 0.9.27 identifier completion completes some keywords.

Identifier completion shows even those identifiers, that are not compatible.

Prefix

You can start identifier completion in a word. Then the letters to the left will be taken as prefix. For example:

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

The box will show you only the identifiers beginning with 'Ca'.

Keys

• Letter or number: add the character to the source editor and the current prefix. This will update the list.
• Backspace: remove the last character from source editor and prefix. Updates the list.
• Return: replace the whole word at cursor with the selected identifier and close the popup window.
• Shift+Return: as Return, but replaces only the prefix (left part) of the word at the cursor.
• Up/Down: move selection
• Escape: close popup without change
• Tab: completes the prefix to next choice. For example: The current prefix is 'But' and the identifier completion only shows 'Button1' and 'Button1Click'. Then pressing Tab will complete the prefix to 'Button1'.
• Else: as Return and add the character to the source editor

Methoden

When cursor is in a class definition and you identifier complete a method defined in an ancestor class the parameters and the override keyword will be added automatically. For example:

<Delphi> TMainForm = class(TForm) protected

 mous|

end; </DELPHI>

Completing MouseDown gives:

<Delphi> TMainForm = class(TForm) protected

 procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X,
        Y: Integer); override;

end; </DELPHI>

Eigenschaften

<Delphi> property MyInt: integer read |; </DELPHI>

Identifier completion will show FMyInt and GetMyInt.

<Delphi> property MyInt: integer write |; </DELPHI>

Identifier completion will show FMyInt and SetMyInt.

Uses section / Unit names

In uses sections the identifier completion will show the filenames of all units in the search path. These will show all lowercase (e.g. avl_tree), because most units have lowercase filenames. On completion it will insert the nice case of the unit (e.g. AVL_Tree).

Statements

<DELPHI> procedure TMainForm.Button1Click(Sender: TObject); begin

 ModalRe|;

end; </DELPHI>

becomes:

<DELPHI> procedure TMainForm.Button1Click(Sender: TObject); begin

 ModalResult:=|;

end; </DELPHI>

Word Completion

"Word Completion" is invoked by Strg+W. It shows all words of all currently open editors.

Otherwise works the same as identifier completion.

Goto Include Directive

"Zu Include Direktive springen" im Suche Menü 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 dies 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 das executable. Um eine .lpi Datei zu erzeugen nur mit den Basisinformationen und nur den Quellen, zusammen mit allen Unterverzeichnissen verwenden Sie "Projekt veröffentlichen".

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.

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.

Ursprüngliche Mitwirkende

Diese Seite wurde von der epikwiki Version konvertiert.

• Seite und anfängliche Vorlage erstellt - 4/6/2004 VlxAdmin
• Anfangsinhalt eingestellt - 4/10/2004 MattiasG
• Kleine Wiki- und Formatierungs-Berichtigungen - 4/11/2004 VlxAdmin
• Ergebnistabelle für IDETools shortcuts hinzugefügt - 12 July 2004 User:Kirkpatc