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

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

• 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 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;