Lazarus IDE Tools/de

From Lazarus wiki
Revision as of 21:13, 29 October 2010 by Mischi (talk | contribs) (spell check and wording)
Jump to navigationJump to search

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 um Pascal Quelltext zu parsen und erweitern, 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, Delphi und 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.

Übersichtstabelle der IDE Tastenkombinationen

Declaration Jumping Strg + Klick (springt zur Deklaration eines type oder Variablen)
Method Jumping Strg + Shift + (schaltet zwischen Definition und Rumpf um)
Code-Schablonen Strg + J
Codevervollständigung (Class Completion) Strg + Shift + C
Bezeichnervervollständigung Strg + Space
Word Completion Strg + W
Parameter Hinweise Strg + Shift + Space
Incremental Search Strg + E

Method Jumping

Um zwischen einem Prozedurrumpf (begin..end) und der Prozedurendefinition (procedure Name;) zu springen verwenden sie Strg+Shift+Up.

Zum Beispiel:

interface

procedure DoSomething; // Prozedurendefinition
 
implementation
 
procedure DoSomething; // Prozedurrumpf 
begin
end;

Wenn der Cursor auf dem Prozedurrumpf ist und sie Strg+Shift+Up drücken, dann wird der Cursor zur Definition springen. Erneutes Drücken von Strg+Shift+Up 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 Cursor 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 Cursor auf dem 'string' Schlüsselwort positionieren. Dies kann verwendet werden für das Umbenennen von Methoden und/oder dem Ä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 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 umbenennen. Das funktioniert ebenfalls für Parameter.

Include Dateien

Include Dateien sind Dateien, die mit der ($I Dateiname) oder ($INCLUDE Dateiname) 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.

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 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 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. You can also hint the IDE by putting

{%mainunit yourunit.pas} 

on the top of 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', hinterlassen den Cursor rechts hinter dem 'f' und drücken 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 Cursor an eine freie Stelle positionieren (nicht auf einem Bezeichner) und Strg+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.

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 Strg+Shift+Space. Eine Hinweisbox erscheint mit den Parametern von FillRect.

Incremental Search

Incremental Search changes the statusbar of the source editor. Type some characters and the editor will search and highlight immediately all occurrences in the text.

  • For example pressing 'e' will search and highlight all occurrences of 'e'.
  • Then pressing 't' will search and highlight all occurrences of 'et' and so forth.
  • You can jump to the next with F3 (or Strg-e while in search) and the previous with Shift+F3.
  • Backspace deletes the last character
  • return stops the search without adding a new line in the editor.
  • You can resume the last search by pressing Strg-e a 2nd time, immediately after you started incr-search with Strg-e. that is while the search term is still empty.
  • Paste Strg-V will append the text from the clipboard to the current search text (since lazarus 0.9.27 r19824).

Hinweis: Quick searching an identifier with incremental search

  • Place text cursor on identifier (do not select anything)
  • Press Ctrl+C. The source editor will select the identifier and copy it to the clipboard
  • Press Ctrl+E to start incremental search
  • Press Ctrl+V to search for the identifier (since 0.9.27)
  • Use F3 and Shift+F3 to quickly jump to next/previous.
  • Use any key (for example cursor left or right) to end the search

Find next / previous word occurrence

Die zwei Funktionen sind im Kontextmenü des Quelltexteditors zu finden

  • Source editor / popup menu / Find / Find next word occurrence
  • Source editor / popup menu / Find / Find previous word occurrence

And you can assign them shortcuts in the editor options.

Codevervollständigung

Codevervollständigung ist zu finden im IDE Menü Bearbeiten -> Quelltext vervollständigen und hat als standard short cut Strg+Shift+C.

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

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

  • Class Completion: komplettiert Eigenschaften, fügt Methodenrümpfe hinzu sowie private Variablen und private Zugriffsmethoden
  • Forward Procedure Completion: fügt Prozedurenrümpfe hinzu
  • Event Assignment Completion: completes event assignments and adds method definition and body
  • Variable Declaration Completion: fügt lokale Variablendefinitionen hinzu
  • Reversed class completion: fügt Methoden-Deklarationen für Methodenrümpfe hinzu

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

Die Codevervollständigung ist im IDE Menü zu finden unter Bearbeiten -> Quelltext vervollständigen und hat den standard short cut Strg+Shift+C.

Class Completion

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.

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 Cursor irgendwo in der Klasse und drücken Strg+Shift+C. Dies wird die fehlenden Methodenrümpfe erzeugen und den Cursor zu dem ersten erzeugten Methodenrumpf bewegen, so dass sie jetzt mit dem Schreiben des class Codes beginnen können:

{ TExample }

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 Strg+Shift+Up.

Sie können sehen, dass die IDE auch den 'inherited Destroy' Aufruf hinzugefügt hat. Dies wird getan, wenn es ein 'override' Schlüsselwort in der class Definition 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 können sehen, dass 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
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 werden 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+Up zu der Klasse, um die neue class 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 'property' (Eigenschaft) wurde um einen Lese- und Schreibzugriff erweitert. Die Klasse erhielt den neuen Abschnitt 'private' mit einer Variable 'FAnInteger' und der Methode '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, können Sie es ändern unter Einstellungen -> Codetools Einstellungen -> Quelltexterzeugung.

Creating a read only property:

property PropName: PropType read;

Wird erweitert zu

property PropName: PropType read FPropName;

Creating a write only property:

 property PropName: PropType write;

Wird erweitert zu

property PropName: PropType write SetPropName;

Creating a read only property with a Read method:

property PropName: PropType read GetPropName;

Will be kept and a GetPropName function will be added:

function GetpropName: PropType;

Creating a property with a stored modifier:

property PropName: PropType stored;

Wird erweitert zu

property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;

Because stored is used for streaming read and write modifiers are automatically added as well.

Hinweis: Bezeichnervervollständigung also recognizes incomplete properties and will suggest the default names. Zum Beispiel:

property PropName: PropType read |;

Platzieren sie den Cursor eine Leerstelle hinter dem 'read' Schlüsselwort und drücken Strg+Space für die Bezeichnervervollständigung. Es wird ihnen die Variable 'FPropName' und die Prozedur 'SetPropName' präsentieren.

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.

Zum Beispiel: Fügen sie eine neue Prozedur zum interface Abschnitt hinzu:

procedure DoSomething;

Platzieren sie den Cursor darauf und drücken 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+Up.

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.

Mehrere Prozeduren:

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

Code Completion wird alle 3 Prozedurrümpfe hinzufügen (Proc2_New, Proc3_New, Proc4_New).

Warum wird es 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