Sign in Join
Wiki copytemporary

Lazarus IDE Tools/de: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

OldNewLine
11## Überblick
22
33Die 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).
44
55Weil 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.
66
77## Übersichtstabelle der IDE-Tastenkombinationen
88
99| | |
1010|----|----|
11-| [[Lazarus IDE Tools/de|Declaration Jumping]] | <span class="kbd">Strg</span>+Klick (springt zur Deklaration eines Typs oder einer Variablen) |
12-| [[Lazarus IDE Tools/de|Methodenspringen]] | <span class="kbd">Strg</span>+<span class="kbd">Shift</span>+<span class="kbd">Up</span> (schaltet zwischen Definition und Rumpf einer Prozedur/Methode um) |
13-| [[Lazarus IDE Tools/de|Code-Schablonen]] | <span class="kbd">Strg</span>+<span class="kbd">J</span> |
14-| [[Lazarus IDE Tools/de|Synchronbearbeitung]] | <span class="kbd">Strg</span>+<span class="kbd">J</span> (bei ausgewähltem Text) |
15-| [[Lazarus IDE Tools/de|Codevervollständigung]] (Klassenvervollständigung) | <span class="kbd">Strg</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> |
16-| [[Lazarus IDE Tools/de|Bezeichner-Vervollständigung]] | <span class="kbd">Strg</span>+<span class="kbd">Space</span> |
17-| [[Lazarus IDE Tools/de|Wortvervollständigung]] | <span class="kbd">Strg</span>+<span class="kbd">W</span> |
18-| [[Lazarus IDE Tools/de|Parameter-Hinweise]] | <span class="kbd">Strg</span>+<span class="kbd">Shift</span>+<span class="kbd">Space</span> |
19-| [[Lazarus IDE Tools/de|Inkrementelle Suche]] | <span class="kbd">Strg</span>+<span class="kbd">E</span> |
20-| [[Lazarus IDE Tools/de|Bezeichner umbenennen]] | <span class="kbd">Strg</span>+<span class="kbd">Shift</span>+<span class="kbd">E</span> |
11+| [[Lazarus IDE Tools/de|Declaration Jumping]] | `Strg`+Klick (springt zur Deklaration eines Typs oder einer Variablen) |
12+| [[Lazarus IDE Tools/de|Methodenspringen]] | `Strg`+`Shift`+`Up` (schaltet zwischen Definition und Rumpf einer Prozedur/Methode um) |
13+| [[Lazarus IDE Tools/de|Code-Schablonen]] | `Strg`+`J` |
14+| [[Lazarus IDE Tools/de|Synchronbearbeitung]] | `Strg`+`J` (bei ausgewähltem Text) |
15+| [[Lazarus IDE Tools/de|Codevervollständigung]] (Klassenvervollständigung) | `Strg`+`Shift`+`C` |
16+| [[Lazarus IDE Tools/de|Bezeichner-Vervollständigung]] | `Strg`+`Space` |
17+| [[Lazarus IDE Tools/de|Wortvervollständigung]] | `Strg`+`W` |
18+| [[Lazarus IDE Tools/de|Parameter-Hinweise]] | `Strg`+`Shift`+`Space` |
19+| [[Lazarus IDE Tools/de|Inkrementelle Suche]] | `Strg`+`E` |
20+| [[Lazarus IDE Tools/de|Bezeichner umbenennen]] | `Strg`+`Shift`+`E` |
2121
2222## Methodenspringen
2323
24-Um zwischen einem Prozedurrumpf (begin..end) und der Prozedurdefinition (procedure Name;) zu springen, verwenden Sie <span class="kbd">Strg</span>+<span class="kbd">Shift</span>+<span class="kbd">Nach oben</span>.
24+Um zwischen einem Prozedurrumpf (begin..end) und der Prozedurdefinition (procedure Name;) zu springen, verwenden Sie `Strg`+`Shift`+`Nach oben`.
2525
2626Zum Beispiel:
2727
2828``` pascal
2929interface
3030
3131procedure DoSomething; // Prozedurdefinition
3232
3333implementation
3434
3535procedure DoSomething; // Prozedurrumpf
3636begin
3737end;
3838```
3939
40-Wenn der Cursor auf dem Prozedurrumpf ist und Sie <span class="kbd">Strg</span>+<span class="kbd">Shift</span>+<span class="kbd">Nach oben</span> drücken, dann wird der Kursor zur Definition springen. Erneutes Drücken von <span class="kbd">Strg</span>+<span class="kbd">Shift</span>+<span class="kbd">Nach oben</span> wird wieder zum Rumpf springen, nach 'begin'.
40+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'.
4141
4242Dies funktioniert ebenfalls zwischen Methoden (Prozeduren in Klassen).
4343
4444Hinweise: 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).
4545
4646Zum Beispiel eine Prozedur mit verschiedenen Parametertypen:
4747
4848``` pascal
4949interface
5050
5151procedure DoSomething(p: char); // Prozedurdefinition
5252
5353implementation
5454
5555procedure DoSomething(p: string); // Prozedurrumpf
5656begin
5757end;
5858```
5959
6060Das 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.
6161
6262Zum Beispiel:\
6363Sie benannten 'DoSomething' in 'MakeIt' um:
6464
6565``` pascal
6666interface
6767
6868procedure MakeIt; // Prozedurdefinition
6969
7070implementation
7171
7272procedure DoSomething; // Prozedurrumpf
7373begin
7474end;
7575```
7676
7777Dann 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.
7878
7979## Include-Dateien
8080
8181Include-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.
8282
8383Im 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.
8484
8585Zum 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.
8686
8787Aber 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.
8888
8989Sobald 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
9090
9191``` pascal
9292{%mainunit yourunit.pas}
9393```
9494
9595am Anfang Ihrer yourinclude.inc.
9696
9797Dieser Mechanismus hat natürlich Grenzen. Einige Include-Dateien sind zweimal oder mehrfach einbezogen. Zum Beispiel: lcl/include/winapih.inc.
9898
9999Das 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. ;)
100100
101101## Code-Schablonen
102102
103103Code-Schablonen konvertieren einen Bezeichner in einen Text oder Code-Fragment.
104104
105-Die Code-Schablonen Vorgabetastenkombination ist <span class="kbd">Strg</span>+<span class="kbd">J</span>. Sie können einen Bezeichner eintippen, <span class="kbd">Strg</span>+<span class="kbd">J</span> 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.
105+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.
106106
107-Beispiel: Schreiben Sie den Bezeichner 'classf', lassen Sie den Kursor hinter dem 'f' stehen und drücken Sie <span class="kbd">Strg</span>+<span class="kbd">J</span>. Das 'classf' wird ersetzt durch
107+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
108108
109109``` pascal
110110T = class(T)
111111private
112112
113113public
114114 constructor Create;
115115 destructor Destroy; override;
116116end;
117117```
118118
119-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 <span class="kbd">Strg</span>+<span class="kbd">J</span> drücken. Die Liste der Code-Schablonen wird auftauchen. Verwenden Sie die Kursortasten oder tippen Sie einige Buchstaben um eine auszuwählen. <span class="kbd">Eingabe</span> erzeugt die gewählte Vorlage und <span class="kbd">Escape</span>schließt das Popup-Fenster.
119+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 `Escape`schließt das Popup-Fenster.
120120
121-Die größten Zeitsparer sind die Schablonen 'b'+<span class="kbd">Strg</span>+<span class="kbd">J</span> für begin..end.
121+Die größten Zeitsparer sind die Schablonen 'b'+`Strg`+`J` für begin..end.
122122
123123## Parameter-Hinweise
124124
125125Parameter-Hinweise zeigen eine Hinweisbox mit den Parameter-Deklarationen für die aktuelle Parameterliste.
126126
127127Zum Beispiel
128128
129129``` pascal
130130 Canvas.FillRect(|);
131131```
132132
133-Platzieren Sie den Cursor in den Klammern und drücken Sie <span class="kbd">Strg</span>+<span class="kbd">Shift</span>+<span class="kbd">Leertaste</span>. Eine Hinweisbox erscheint mit den Parametern von FillRect.
133+Platzieren Sie den Cursor in den Klammern und drücken Sie `Strg`+`Shift`+`Leertaste`. Eine Hinweisbox erscheint mit den Parametern von FillRect.
134134
135-<figure>
136-<img src="Parameterhints1.png" title="Parameterhints1.png" />
137-<figcaption>Parameterhints1.png</figcaption>
138-</figure>
135+![](/wiki-images/c/c8/Parameterhints1.png)
139136
140137Seit 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.
141138
142-<figure>
143-<img src="Parameterhints2.png" title="Parameterhints2.png" />
144-<figcaption>Parameterhints2.png</figcaption>
145-</figure>
139+![](/wiki-images/4/48/Parameterhints2.png)
146140
147141Tipp: Benutzen Sie die Variable Declaration Completion um Variablen zu deklarieren.
148142
149143Beachten Sie: Der Name des Tastenkürzels ist "Code-Context anzeigen".
150144
151145## Inkrementelle Suche
152146
153-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 <span class="kbd">Strg</span>+<span class="kbd">E</span>.
147+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`.
154148
155-- Zum Beispiel: Sie drücken <span class="kbd">A</span>, sucht und markiert alle Fundstellen von 'A'.
156-- Dann drücken Sie <span class="kbd">T</span> und alle Fundstellen von 'at' sind markiert usw.
157-- Sie springen zur nächsten Fundstelle mit <span class="kbd">F3</span> (oder <span class="kbd">Strg</span>+<span class="kbd">E</span> während der Suche) und zur vorigen Fundstelle mit <span class="kbd">Umschalt</span>+<span class="kbd">F3</span>.
158-- <span class="kbd">Backspace</span> entfernt das letzte Zeichen
159-- <span class="kbd">Eingabe</span> stoppt die Suche ohne eine neue Zeile im Editor.
160-- Sie nehmen die letzte Suche erneut auf mit einem zweiten <span class="kbd">Strg</span>+<span class="kbd">E</span>, sofort nach dem Start der Suche mit <span class="kbd">Strg</span>+<span class="kbd">E</span>. Das gilt solange das Suchfeld noch leer ist.
161-- Einfügen mit <span class="kbd">Strg</span>+<span class="kbd">V</span> hängt den Text aus der Zwischenablage an den aktuellen Suchtext an (seit Lazarus 0.9.27 r19824).
149+- Zum Beispiel: Sie drücken `A`, sucht und markiert alle Fundstellen von 'A'.
150+- Dann drücken Sie `T` und alle Fundstellen von 'at' sind markiert usw.
151+- Sie springen zur nächsten Fundstelle mit `F3` (oder `Strg`+`E` während der Suche) und zur vorigen Fundstelle mit `Umschalt`+`F3`.
152+- `Backspace` entfernt das letzte Zeichen
153+- `Eingabe` stoppt die Suche ohne eine neue Zeile im Editor.
154+- 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.
155+- Einfügen mit `Strg`+`V` hängt den Text aus der Zwischenablage an den aktuellen Suchtext an (seit Lazarus 0.9.27 r19824).
162156
163157### Hinweis: Schnelle Suche nach einem Bezeichner mit der inkrementellen Suche
164158
165159- Stellen Sie den Textkursor auf den Bezeichner. (Wählen Sie nichts aus!)
166-- Drücken Sie <span class="kbd">Strg</span>+<span class="kbd">C</span>. Der Editor wählt den Bezeichner aus und kopiert ihn in die Zwischenablage
167-- Drücken Sie <span class="kbd">Strg</span>+<span class="kbd">E</span> - startet die inkrementelle Suche
168-- Drücken Sie <span class="kbd">Strg</span>+<span class="kbd">V</span> - sucht nach dem Bezeichner (seit Version 0.9.27)
169-- Mit <span class="kbd">F3</span> und <span class="kbd">Umschalt</span>+<span class="kbd">F3</span> springen Sie zum nächsten/vorigen Fund.
160+- Drücken Sie `Strg`+`C`. Der Editor wählt den Bezeichner aus und kopiert ihn in die Zwischenablage
161+- Drücken Sie `Strg`+`E` - startet die inkrementelle Suche
162+- Drücken Sie `Strg`+`V` - sucht nach dem Bezeichner (seit Version 0.9.27)
163+- Mit `F3` und `Umschalt`+`F3` springen Sie zum nächsten/vorigen Fund.
170164- Mit einer beliebigen Taste (beispielsweise Kursor links oder rechts) beenden Sie die Suche
171165
172166## Synchronbearbeitung
173167
174168Die 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.
175169
176170Die Synchronbearbeitung verarbeitet alle Worte in einem ausgewählten Bereich:
177171
178172- Selektieren Sie einen Textblock
179-- Drücken Sie <span class="kbd">Strg</span>+<span class="kbd">J</span> oder klicken Sie auf das Symbol in der Randleiste. (Das funktioniert nur, wenn Worte in der Auswahl mehr als einmal auftreten.)
180-- Benutzen Sie die <span class="kbd">Tab</span>-Taste, um das zu bearbeitende Wort auszuwählen (wenn einige verschiedene Wörter mehrfach auftreten).
173+- 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.)
174+- Benutzen Sie die `Tab`-Taste, um das zu bearbeitende Wort auszuwählen (wenn einige verschiedene Wörter mehrfach auftreten).
181175- Bearbeiten Sie das Wort.
182-- Drücken Sie <span class="kbd">Esc</span> zum Beenden
176+- Drücken Sie `Esc` zum Beenden
183177
184178Sehen Sie sich [[New IDE features since|hier]] ein animiertes Beispiel an.
185179
186-- Anmerkung: <span class="kbd">Strg</span>+<span class="kbd">J</span> wird auch beim Bearbeiten von Vorlagen benutzt. Die Bedeutung ändert sich, wenn Sie einen Text auswählen.
180+- Anmerkung: `Strg`+`J` wird auch beim Bearbeiten von Vorlagen benutzt. Die Bedeutung ändert sich, wenn Sie einen Text auswählen.
187181
188182## Suche nächste / vorhergehende Fundstelle des Wortes
189183
190184Die zwei Funktionen sind im Kontextmenü des Quelltexteditors zu finden
191185
192186- Quelltexteditor / Kontextmenü / Suchen / Nächste Fundstelle des Wortes
193187- Quelltexteditor / Kontextmenü / Suchen / Vorhergehende Fundstelle des Wortes
194188
195189Und Sie können diesen Funktionen in den Editoreinstellungen ein Tastenkürzel zuweisen.
196190
197191## Codevervollständigung
198192
199-Die Codevervollständigung ist im IDE-Menü zu finden unter Bearbeiten -\> Quelltext vervollständigen und hat das Standardkürzel <span class="kbd">Strg</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span>.
193+Die Codevervollständigung ist im IDE-Menü zu finden unter Bearbeiten -\> Quelltext vervollständigen und hat das Standardkürzel `Strg`+`Shift`+`C`.
200194
201-Für Delphianer: Delphi bezeichnet mit "Codevervollständigung" die Funktion, die die Liste der Bezeichner an der aktuellen Quellenposition zeigt (<span class="kbd">Strg</span>+<span class="kbd">Leertaste</span>). Unter Lazarus wird dies *Bezeichnervervollständigung* genannt.
195+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.
202196
203197*Codevervollständigung* kombiniert verschiedene mächtige Funktionen. Beispiele:
204198
205199- Class Completion: komplettiert Eigenschaften; fügt Methodenrümpfe, private Variablen und private Zugriffsmethoden hinzu
206200- Forward Procedure Completion: fügt Prozedurenrümpfe hinzu
207201- Event Assignment Completion: komplettiert Ereigniszuweisungen; fügt Methodendefinition und -rumpf hinzu
208202- Variable Declaration Completion: fügt lokale Variablendefinitionen hinzu
209203- Reversed Class Completion: fügt Methoden-Deklarationen für Methodenrümpfe hinzu
210204- Procedure Call Completion: fügt eine neue Prozedur hinzu
211205- Reversed procedure completion: fügt Deklarationen für Prozedur-/Funktionsrümpfe hinzu
212206
213207Welche Funktion genutzt wird, hängt von der Kursorposition im Editor ab und wird unten beschrieben.
214208
215-Die Codevervollständigung ist im IDE-Menü zu finden unter Bearbeiten -\> Quelltext vervollständigen und hat das Standardkürzel <span class="kbd">Strg</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span>.
209+Die Codevervollständigung ist im IDE-Menü zu finden unter Bearbeiten -\> Quelltext vervollständigen und hat das Standardkürzel `Strg`+`Shift`+`C`.
216210
217211### Class Completion
218212
219213Das 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.
220214
221215Zum Beispiel: Erzeugen Sie eine Klasse (siehe Code-Schablonen, um einige Tipparbeit zu sparen):
222216
223217``` pascal
224218TExample = class(TObject)
225219public
226220 constructor Create;
227221 destructor Destroy; override;
228222end;
229223```
230224
231-Positionieren Sie den Kursor irgendwo in der Klasse und drücken Sie <span class="kbd">Strg</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span>. 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:
225+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:
232226
233227``` pascal
234228{ TExample }
235229
236230constructor TExample.Create;
237231begin
238232 |
239233end;
240234
241235destructor TExample.Destroy;
242236begin
243237 inherited Destroy;
244238end;
245239```
246240
247241Anmerkung: Das '\|' ist der Kursor und nicht hinzugefügt.
248242
249-Hinweis: Sie können zwischen einer Methode und ihrem Rumpf springen mit <span class="kbd">Strg</span>+<span class="kbd">Shift</span>+<span class="kbd">Nach oben</span>.
243+Hinweis: Sie können zwischen einer Methode und ihrem Rumpf springen mit `Strg`+`Shift`+`Nach oben`.
250244
251245Sie 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.
252246
253247Jetzt fügen Sie eine Methode DoSomething hinzu:
254248
255249``` pascal
256250TExample = class(TObject)
257251public
258252 constructor Create;
259253 procedure DoSomething(i: integer);
260254 destructor Destroy; override;
261255end;
262256```
263257
264-Dann drücken Sie <span class="kbd">Strg</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> und die IDE wird hinzufügen:
258+Dann drücken Sie `Strg`+`Shift`+`C` und die IDE wird hinzufügen:
265259
266260``` pascal
267261procedure TExample.DoSomething(i: integer);
268262begin
269263 |
270264end;
271265```
272266
273267Sie 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.
274268
275269**Complete Properties**\
276270Fügen Sie eine Eigenschaft 'AnInteger' hinzu:
277271
278272``` pascal
279273TExample = class(TObject)
280274public
281275 constructor Create;
282276 procedure DoSomething(i: integer);
283277 destructor Destroy; override;
284278 property AnInteger: Integer;
285279end;
286280```
287281
288-Drücken Sie <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> und Sie erhalten:
282+Drücken Sie `Ctrl`+`Shift`+`C` und Sie erhalten:
289283
290284``` pascal
291285procedure TExample.SetAnInteger(const AValue: integer);
292286begin
293287 |if FAnInteger=AValue then exit;
294288 FAnInteger:=AValue;
295289end;
296290```
297291
298-Die Codevervollständigung hat den Schreibzugriff geändert und den üblichen Code ergänzt. Springen Sie mit <span class="kbd">Strg</span>+<span class="kbd">Shift</span>+<span class="kbd">Nach oben</span> zur Klasse, um die neue Klasse ganz zu sehen:
292+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:
299293
300294``` pascal
301295TExample = class(TObject)
302296private
303297 FAnInteger: integer;
304298 procedure SetAnInteger(const AValue: integer);
305299public
306300 constructor Create;
307301 procedure DoSomething(i: integer);
308302 destructor Destroy; override;
309303 property AnInteger: integer read FAnInteger write SetAnInteger;
310304end;
311305```
312306
313307Die 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.
314308
315309Erzeugen einer Eigenschaft 'read only':
316310
317311``` pascal
318312property PropName: PropType read;
319313```
320314
321315wird erweitert zu
322316
323317``` pascal
324318property PropName: PropType read FPropName;
325319```
326320
327321Erzeugen einer Eigenschaft 'write only':
328322
329323``` pascal
330324property PropName: PropType write;
331325```
332326
333327wird erweitert zu
334328
335329``` pascal
336330property PropName: PropType write SetPropName;
337331```
338332
339333Erzeugen einer Eigenschaft 'read only' mit einer Read-Methode:
340334
341335``` pascal
342336property PropName: PropType read GetPropName;
343337```
344338
345339wird beibehalten und eine Funktion 'GetPropName' wird angefügt:
346340
347341``` pascal
348342function GetpropName: PropType;
349343```
350344
351345Erzeugen einer Eigenschaft mit einem stored-Modifizierer:
352346
353347``` pascal
354348property PropName: PropType stored;
355349```
356350
357351wird erweitert zu
358352
359353``` pascal
360354property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;
361355```
362356
363357Weil 'stored' für das Streaming benutzt wird, werden automatisch auch die read- und write-Modifizierer angefügt.
364358
365359Hinweis: Die *Bezeichnervervollständigung* erkennt auch unvollständige Eigenschaften und wird die Standardnamen vorschlagen. Zum Beispiel:
366360
367361``` pascal
368362property PropName: PropType read |;
369363```
370364
371365Platzieren 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.
372366
373367### Forward Procedure Completion
374368
375369Die *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.
376370
377371Zum Beispiel: Fügen Sie eine neue Prozedur zum Interface-Abschnitt hinzu:
378372
379373``` pascal
380374procedure DoSomething;
381375```
382376
383-Platzieren Sie den Kursor darauf und drücken Sie <span class="kbd">Strg</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> für Codevervollständigung. Es wird im Implementation-Abschnitt erzeugen:
377+Platzieren Sie den Kursor darauf und drücken Sie `Strg`+`Shift`+`C` für Codevervollständigung. Es wird im Implementation-Abschnitt erzeugen:
384378
385379``` pascal
386380procedure DoSomething;
387381begin
388382 |
389383end;
390384```
391385
392-Hinweis: Sie können zwischen einer Prozedurdefinition und ihrem Rumpf springen mit <span class="kbd">Strg</span>+<span class="kbd">Shift</span>+<span class="kbd">Nach oben</span>.
386+Hinweis: Sie können zwischen einer Prozedurdefinition und ihrem Rumpf springen mit `Strg`+`Shift`+`Nach oben`.
393387
394388Der 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:
395389
396390``` pascal
397391procedure Proc1;
398392procedure Proc2; // neue Prozedur
399393procedure Proc3;
400394```
401395
402396Wenn 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.
403397
404398Mehrere Prozeduren:
405399
406400``` pascal
407401procedure Proc1_Old; // Rumpf existiert
408402procedure Proc2_New; // Rumpf existiert nicht
409403procedure Proc3_New; // "
410404procedure Proc4_New; // "
411405procedure Proc5_Old; // Rumpf existiert
412406```
413407
414408Die Codevervollständigung wird alle 3 Prozedurrümpfe hinzufügen (Proc2_New, Proc3_New, Proc4_New).
415409
416410Warum wird das *Forward Procedure Completion* genannt?
417411
418412Weil 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.
419413
420414### Event Assignment Completion
421415
422416Die "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.
423417
424418Zum Beispiel: In einer Methode, sagen wir dem FormCreate Ereignis, fügen wir eine Zeile 'OnPaint:=' hinzu:
425419
426420``` pascal
427421procedure TForm1.Form1Create(Sender: TObject);
428422begin
429423 OnPaint:=|
430424end;
431425```
432426
433427Das '\|' 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
434428
435429``` pascal
436430OnPaint:=@Form1Paint;
437431```
438432
439433Eine neue Methode Form1Paint wird zur Klasse TForm1 hinzugefügt. Dann wird die *class completion* gestartet und Sie erhalten:
440434
441435``` pascal
442436procedure TForm1.Form1Paint(Sender: TObject);
443437begin
444438 |
445439end;
446440```
447441
448442Das funktioniert wie das Hinzufügen von Methoden im Objektinspektor.
449443
450444Anmerkung:\
451445Sie 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.
452446
453447Hinweis:\
454448Sie können den neuen Methodennamen selbst definieren. Zum Beispiel:
455449
456450``` pascal
457451OnPaint:=@ThePaintMethod;
458452```
459453
460454### Variable Declaration Completion
461455
462456Die "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.
463457
464458Zum Beispiel:
465459
466460``` pascal
467461procedure TForm1.Form1Create(Sender: TObject);
468462begin
469463 i:=3;
470464end;
471465```
472466
473-Platzieren Sie den Kursor auf dem 'i' oder genau dahinter. Dann drücken Sie <span class="kbd">Strg</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> für die Codevervollständigung und Sie erhalten:
467+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:
474468
475469``` pascal
476470procedure TForm1.Form1Create(Sender: TObject);
477471var
478472 i: Integer;
479473begin
480474 i:=3;
481475end;
482476```
483477
484478Die 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.
485479
486480Ein anderes Beispiel:
487481
488482``` pascal
489483type
490484 TWhere = (Behind, Middle, InFront);
491485
492486 procedure TForm1.Form1Create(Sender: TObject);
493487 var
494488 a: array[TWhere] of char;
495489 begin
496490 for Where:=Low(a) to High(a) do writeln(a[Where]);
497491 end;
498492```
499493
500-Platzieren Sie den Kursor auf 'Where' und drücken Sie <span class="kbd">Strg</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> für die Codevervollständigung. Sie erhalten:
494+Platzieren Sie den Kursor auf 'Where' und drücken Sie `Strg`+`Shift`+`C` für die Codevervollständigung. Sie erhalten:
501495
502496``` pascal
503497 procedure TForm1.Form1Create(Sender: TObject);
504498 var
505499 a: array[TWhere] of char;
506500 Where: TWhere;
507501 begin
508502 for Where:=Low(a) to High(a) do writeln(a[Where]);
509503 end;
510504```
511505
512506Seit Version 0.9.11 komplettiert Lazarus auch Parameter. Zum Beispiel
513507
514508``` pascal
515509 procedure TForm1.FormPaint(Sender: TObject);
516510 begin
517511 with Canvas do begin
518512 Line(x1,y1,x2,y2);
519513 end;
520514 end;
521515```
522516
523-Platzieren Sie den Kursor auf 'x1' und drücken Sie <span class="kbd">Strg</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> für die Codevervollständigung. Sie erhalten:
517+Platzieren Sie den Kursor auf 'x1' und drücken Sie `Strg`+`Shift`+`C` für die Codevervollständigung. Sie erhalten:
524518
525519``` pascal
526520 procedure TForm1.FormPaint(Sender: TObject);
527521 var
528522 x1: integer;
529523 begin
530524 with Canvas do begin
531525 Line(x1,y1,x2,y2);
532526 end;
533527 end;
534528```
535529
536530### Procedure Call Completion
537531
538532Die Codevervollständigung kann auch eine neue Prozedur aus dem Prozeduraufruf selbst erzeugen.
539533
540534Angenommen, Sie haben gerade die Anweisung "DoSomething(Width);" geschrieben
541535
542536``` pascal
543537procedure SomeProcedure;
544538var
545539 Width: integer;
546540begin
547541 Width:=3;
548542 DoSomething(Width);
549543end;
550544```
551545
552-Platzieren Sie den Kursor über dem Bezeichner "DoSomething" und drücken Sie <span class="kbd">Strg</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span>. Sie erhalten:
546+Platzieren Sie den Kursor über dem Bezeichner "DoSomething" und drücken Sie `Strg`+`Shift`+`C`. Sie erhalten:
553547
554548``` pascal
555549procedure DoSomething(aWidth: LongInt);
556550begin
557551
558552end;
559553
560554procedure SomeProcedure;
561555var
562556 Width: integer;
563557begin
564558 Width:=3;
565559 DoSomething(Width);
566560end;
567561```
568562
569563Es werden derzeit noch keine Funktionen oder Methoden erzeugt.
570564
571565### Reversed Class Completion
572566
573567"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.
574568
575569Zum Beispiel:
576570
577571``` pascal
578572 procedure TForm1.DoSomething(Sender: TObject);
579573 begin
580574 end;
581575```
582576
583-Die Methode DoSomething ist noch nicht in TForm1 deklariert. Drücken Sie <span class="kbd">Strg</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> und die IDE wird "procedure DoSomething(Sender: TObject);" zu den privaten Methoden von TForm1 hinzufügen.
577+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.
584578
585579Fü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.
586580
587581### Kommentare und Codevervollständigung
588582
589583Die Codevervollständigung versucht die Kommentare dort zu behalten, wo sie hingehören. Zum Beispiel:
590584
591585``` pascal
592586 FList: TList; // list of TComponent
593587 FInt: integer;
594588```
595589
596590Wenn eine neue Variable zwischen FList und FInt eingesetzt wird, dann wird der Kommentar in der FList Zeile beibehalten. Das selbe gilt für
597591
598592``` pascal
599593 FList: TList; { list of TComponent
600594 Dies ist ein Kommentar über mehrere Zeilen, beginnend
601595 in der FList-Zeile. Die CodeTools nehmen an, er gehöre
602596 zu der FList-Zeile und brechen diese Beziehung nicht
603597 auf. Der Code wird hinter dem Kommentar eingefügt. }
604598 FInt: integer;
605599```
606600
607601Wenn der Kommentar in der nächsten Zeile startet, dann wird er behandelt, wie wenn er zum nachfolgenden Code gehört. Zum Beispiel:
608602
609603``` pascal
610604 FList: TList; // list of TComponent
611605 { Dieser Kommentar gehört zur nachfolgenden Anweisung.
612606 Neuer Code wird oberhalb des Kommentars eingefügt und
613607 hinter dem Kommentar der FList-Zeile. }
614608 FInt: integer;
615609```
616610
617611### Method update
618612
619613Normalerweise 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*.
620614
621615``` pascal
622616 public
623617 procedure DoSomething;
624618 end;
625619
626620procedure TForm.DoSomething;
627621begin
628622end;
629623```
630624
631625Fügen Sie jetzt einen Parameter hinzu:
632626
633627``` pascal
634628 public
635629 procedure DoSomething(i: integer);
636630 end;
637631```
638632
639-und rufen Sie die Codevervollständigung auf mit (<span class="kbd">Strg</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span>). Der Methodenrumpf wird aktualisiert und der neue Parameter wird kopiert:
633+und rufen Sie die Codevervollständigung auf mit (`Strg`+`Shift`+`C`). Der Methodenrumpf wird aktualisiert und der neue Parameter wird kopiert:
640634
641635``` pascal
642636procedure TForm.DoSomething(i: integer);
643637begin
644638end;
645639```
646640
647641## Refactoring
648642
649643### Invert Assignments
650644
651645Kurz gefasst
652646"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.
653647
654648Beispiel:\
655649
656650``` pascal
657651procedure DoSomething;
658652begin
659653 AValueStudio:= BValueStudio;
660654 AValueAppartment :=BValueAppartment;
661655 AValueHouse:=BValueHouse;
662656end;
663657```
664658
665659Wä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:
666660
667661Resultat:
668662
669663``` pascal
670664procedure DoSomething;
671665begin
672666 BValueStudio := AValueStudio;
673667 BValueAppartment := AValueAppartment;
674668 BValueHouse := AValueHouse;
675669end;
676670```
677671
678672### Enclose Selection
679673
680674Wä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.
681675
682676### Bezeichner umbenennen
683677
684678Stellen 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.
685679
686680- 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.
687681- Und es wird zuerst auf Namenskonflikte überprüft.
688682- Beschränkungen: Das funktioniert nur mit Pascal-Quellen, benennt keine Dateinamen um und bearbeitet weder lfm/lrs-Dateien noch lazdoc-Dateien.
689683
690684### Find Identifier References
691685
692686Stellen 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.
693687
694688### Show abstract methods
695689
696690Dieses 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.
697691
698692### Prozedur extrahieren
699693
700694Siehe [[IDE Window: Extract Procedure|Prozedur extrahieren]]
701695
702696## Find Declaration
703697
704698Positionieren 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.
705699
706700Jede *find declaration* setzt einen Sprungpunkt. Das bedeutet, Sie springen mit *find declaration* zur Deklaration und einfach zurück mit Suche -\> Zurückspringen.
707701
708702Es 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:
709703
710704Die *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.
711705
712706Das selbe gilt für Typen wie TColor. Für den Compiler ist es einfach ein 'longint'. Aber in den Quellen ist es definiert als
713707
714708``` pascal
715709TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;
716710TColor = TGraphicsColor;
717711```
718712
719713Und das selbe für **forward defined classes**: Zum Beispiel gibt es in TControl eine private Variable
720714
721715``` pascal
722716FHostDockSite: TWinControl;
723717```
724718
725719Find declaration auf TWinControl springt zur forward definition
726720
727721``` pascal
728722TWinControl = class;
729723```
730724
731725Und ein erneuter Aufruf springt zur realen Implementierung
732726
733727``` pascal
734728TWinControl = class(TControl)
735729```
736730
737731Auf diese Weise können Sie jeden Bezeichner aufspüren und jede Überladung finden.
738732
739733**Tipps:**
740734
741-- Sie können zurück springen mit <span class="kbd">Strg</span>+<span class="kbd">H</span>.
735+- Sie können zurück springen mit `Strg`+`H`.
742736- Sie können alle besuchten Orte anzeigen/erreichen mittels Menü: Ansicht / Sprungliste anzeigen ...
743737- Mit einer 5-Tasten-Maus können Sie die beiden Extratasten dazu verwenden, vorwärts/rückwärts zu den besuchten Orten zu gehen
744738
745739
746740(Sie können die Tastenbelegung ändern mit Menü: Einstellungen / Maus / Erweitert
747741
748742Siehe auch: [[IDE Window: EditorMouseOptionsAdvanced|advanced mouse options]])
749743
750744## Bezeichner-Vervollständigung
751745
752-Die "Bezeichner-Vervollständigung" wird aufgerufen mittels <span class="kbd">Strg</span>+<span class="kbd">space</span>. Sie zeigt alle Bezeichner im Suchbereich. Zum Beipiel:
746+Die "Bezeichner-Vervollständigung" wird aufgerufen mittels `Strg`+`space`. Sie zeigt alle Bezeichner im Suchbereich. Zum Beipiel:
753747
754748``` pascal
755749procedure TForm1.FormCreate(Sender: TObject);
756750begin
757751 |
758752end;
759753```
760754
761-Stellen Sie den Kursor zwischen *begin* und *end* und drücken Sie <span class="kbd">Strg</span>+<span class="kbd">space</span>. 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.
755+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.
762756
763757**Anmerkung für Delphianer:** Delphi nennt das *Code completion*.
764758
765759Einige 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.
766760
767-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 <span class="kbd">Strg</span>+<span class="kbd">W</span> Wortvervollstandigung oder <span class="kbd">Strg</span>+<span class="kbd">J</span> Code-Schablonen. Seit Version 0.9.27 ergänzt die *Bezeichner-Vervollständigung* einige Schlüsselwörter.
761+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.
768762
769763Die Bezeichner-Vervollständigung zeigt sogar solche Bezeichner an, die inkompatibel sind.
770764
771765### Präfix
772766
773767Sie könne die Bezeichner-Vervollständigung mitten in einem Wort starten. Dann werden die Buchstaben links als Präfix genommen. Zum Beispiel:
774768
775769``` pascal
776770procedure TForm1.FormCreate(Sender: TObject);
777771begin
778772 Ca|ption
779773end;
780774```
781775
782776Die Suchliste zeigt Ihnen dann nur diejenigen Bezeichner an, die mit 'Ca' beginnen.
783777
784778### Tasten
785779
786780- Buchstabe oder Ziffer: füge das Zeichen hinzu im Quelltexteditor und im aktuellen Präfix. Dadurch wird die Liste aktualisiert.
787781- Backspace: entfernt das letzte Zeichen aus dem Quelltexteditor und dem Präfix. Aktualisiert die Liste.
788782- Eingabe: ersetzt das ganze Wort am Kursor mit dem ausgewählten Bezeichner und schließt das Popup-Fenster.
789783- Umschalt+Eingabe: wie *Eingabe*, aber ersetzt nur das Präfix (linker Teil) des Wortes am Kursor.
790784- Nach oben/Nach unten: bewegt die Auswahl
791785- Escape: schließt das Popup-Fenster ohne Änderungen
792786- 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.
793787- Else: wie *Eingabe* und fügt das Zeichen zum Quelltexteditor hinzu
794788
795789### Methoden
796790
797791Wenn 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:
798792
799793``` pascal
800794TMainForm = class(TForm)
801795protected
802796 mous|
803797end;
804798```
805799
806800Die Vervollständigung von **MouseDown** ergibt:
807801
808802``` pascal
809803TMainForm = class(TForm)
810804protected
811805 procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X,
812806 Y: Integer); override;
813807end;
814808```
815809
816810### Eigenschaften
817811
818812``` pascal
819813property MyInt: integer read |;
820814```
821815
822816Die Bezeichner-Vervollständigung zeigt Ihnen **FMyInt** und **GetMyInt**.
823817
824818``` pascal
825819property MyInt: integer write |;
826820```
827821
828822Die Bezeichner-Vervollständigung zeigt Ihnen **FMyInt** und **SetMyInt**.
829823
830824### Uses-Abschnitt / Unitnamen
831825
832826In 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**).
833827
834828### Anweisungen
835829
836830``` pascal
837831procedure TMainForm.Button1Click(Sender: TObject);
838832begin
839833 ModalRe|;
840834end;
841835```
842836
843837wird zu:
844838
845839``` pascal
846840procedure TMainForm.Button1Click(Sender: TObject);
847841begin
848842 ModalResult:=|;
849843end;
850844```
851845
852846## Wortvervollständigung
853847
854-Die "Wortvervollständigung" wird aufgerufen mit <span class="kbd">Strg</span>+<span class="kbd">W</span>. 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.
848+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.
855849
856850Ansonsten funktioniert sie genau gleich wie die Bezeichner-Vervollständigung.
857851
858852## Zu Include-Anweisung springen
859853
860854"Zu Include-Anweisung springen" im Menü 'Suchen' der IDE springt zur {\$I filename} Anweisung, wo die aktuelle Include-Datei verwendet wird.
861855
862856## Projekt veröffentlichen
863857
864858Erzeugt eine Kopie des gesamten Projekts. Wenn Sie jemandem einfach die Quellen und Kompilereinstellungen Ihres Codes senden wollen, dann ist diese Funktion Ihr Freund.
865859
866860Ein 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".
867861
868862**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.
869863
870864In 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.
871865
872866## Tipps von Kommentaren
873867
874868An 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:
875869
876870### Kommentare im Tipp angezeigt
877871
878872Kommentare vor einer Deklaration, ohne Leerzeile und nicht mit dem **\<**-Zeichen beginnend:
879873
880874``` pascal
881875var
882876 {Comment}
883877 Identifier: integer;
884878```
885879
886880Kommentare mit dem **\<**-Zeichen gehören zum vorhergehenden Bezeichner.
887881
888882Kommentare hinter einem Bezeichner in der selben Zeile:
889883
890884``` pascal
891885var
892886 identifier, // Comment
893887 other,
894888```
895889
896890Kommentare hinter der Definition in der selben Zeile:
897891
898892``` pascal
899893var
900894 identifier:
901895 char; // Comment
902896```
903897
904898Ein Beispiel für das **\<**-Zeichen:
905899
906900``` pascal
907901const
908902 a = 1;
909903 //< comment for a
910904 b = 2;
911905 // comment for c
912906 c = 3;
913907```
914908
915909Alle drei Kommentartypen werden unterstützt:
916910
917911``` pascal
918912 {Comment}(*Comment*)//Comment
919913 c = 1;
920914```
921915
922916Kommentare, die mit **\$** und **%** beginnen, werden ignoriert.
923917
924918### Kommentare, nicht im Tipp angezeigt
925919
926920Vorlaufende 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:
927921
928922``` pascal
929923type
930924 { TMyClass }
931925
932926 TMyClass = class
933927```
934928
935929Die 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.
936930
937931Der folgende Kommentar wird angezeigt für GL_TRUE, aber nicht für GL_FALSE:
938932
939933``` pascal
940934 // Boolean
941935 GL_TRUE = 1;
942936 GL_FALSE = 0;
943937```
944938
945939---
946940*From the Free Pascal wiki, page "Lazarus IDE Tools/de", as it stood on 2022-02-21 after a change by Kornelius, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).*

Back to history