Lazarus IDE Tools/de: what changed

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

Title: Lazarus IDE Tools/de

New		Line
1	+	## Überblick
2	+
3	+	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).
4	+
5	+	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.
6	+
7	+	## Übersichtstabelle der IDE-Tastenkombinationen
8	+
9	+	\| \| \|
10	+	\|----\|----\|
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> \|
21	+
22	+	## Methodenspringen
23	+
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>.
25	+
26	+	Zum Beispiel:
27	+
28	+	``` pascal
29	+	interface
30	+
31	+	procedure DoSomething; // Prozedurdefinition
32	+
33	+	implementation
34	+
35	+	procedure DoSomething; // Prozedurrumpf
36	+	begin
37	+	end;
38	+	```
39	+
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'.
41	+
42	+	Dies funktioniert ebenfalls zwischen Methoden (Prozeduren in Klassen).
43	+
44	+	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).
45	+
46	+	Zum Beispiel eine Prozedur mit verschiedenen Parametertypen:
47	+
48	+	``` pascal
49	+	interface
50	+
51	+	procedure DoSomething(p: char); // Prozedurdefinition
52	+
53	+	implementation
54	+
55	+	procedure DoSomething(p: string); // Prozedurrumpf
56	+	begin
57	+	end;
58	+	```
59	+
60	+	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.
61	+
62	+	Zum Beispiel:\
63	+	Sie benannten 'DoSomething' in 'MakeIt' um:
64	+
65	+	``` pascal
66	+	interface
67	+
68	+	procedure MakeIt; // Prozedurdefinition
69	+
70	+	implementation
71	+
72	+	procedure DoSomething; // Prozedurrumpf
73	+	begin
74	+	end;
75	+	```
76	+
77	+	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.
78	+
79	+	## Include-Dateien
80	+
81	+	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.
82	+
83	+	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.
84	+
85	+	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.
86	+
87	+	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.
88	+
89	+	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
90	+
91	+	``` pascal
92	+	{%mainunit yourunit.pas}
93	+	```
94	+
95	+	am Anfang Ihrer yourinclude.inc.
96	+
97	+	Dieser Mechanismus hat natürlich Grenzen. Einige Include-Dateien sind zweimal oder mehrfach einbezogen. Zum Beispiel: lcl/include/winapih.inc.
98	+
99	+	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. ;)
100	+
101	+	## Code-Schablonen
102	+
103	+	Code-Schablonen konvertieren einen Bezeichner in einen Text oder Code-Fragment.
104	+
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.
106	+
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
108	+
109	+	``` pascal
110	+	T = class(T)
111	+	private
112	+
113	+	public
114	+	constructor Create;
115	+	destructor Destroy; override;
116	+	end;
117	+	```
118	+
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.
120	+
121	+	Die größten Zeitsparer sind die Schablonen 'b'+<span class="kbd">Strg</span>+<span class="kbd">J</span> für begin..end.
122	+
123	+	## Parameter-Hinweise
124	+
125	+	Parameter-Hinweise zeigen eine Hinweisbox mit den Parameter-Deklarationen für die aktuelle Parameterliste.
126	+
127	+	Zum Beispiel
128	+
129	+	``` pascal
130	+	Canvas.FillRect(\|);
131	+	```
132	+
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.
134	+
135	+	<figure>
136	+	<img src="Parameterhints1.png" title="Parameterhints1.png" />
137	+	<figcaption>Parameterhints1.png</figcaption>
138	+	</figure>
139	+
140	+	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.
141	+
142	+	<figure>
143	+	<img src="Parameterhints2.png" title="Parameterhints2.png" />
144	+	<figcaption>Parameterhints2.png</figcaption>
145	+	</figure>
146	+
147	+	Tipp: Benutzen Sie die Variable Declaration Completion um Variablen zu deklarieren.
148	+
149	+	Beachten Sie: Der Name des Tastenkürzels ist "Code-Context anzeigen".
150	+
151	+	## Inkrementelle Suche
152	+
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>.
154	+
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).
162	+
163	+	### Hinweis: Schnelle Suche nach einem Bezeichner mit der inkrementellen Suche
164	+
165	+	- 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.
170	+	- Mit einer beliebigen Taste (beispielsweise Kursor links oder rechts) beenden Sie die Suche
171	+
172	+	## Synchronbearbeitung
173	+
174	+	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.
175	+
176	+	Die Synchronbearbeitung verarbeitet alle Worte in einem ausgewählten Bereich:
177	+
178	+	- 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).
181	+	- Bearbeiten Sie das Wort.
182	+	- Drücken Sie <span class="kbd">Esc</span> zum Beenden
183	+
184	+	Sehen Sie sich [[New IDE features since\|hier]] ein animiertes Beispiel an.
185	+
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.
187	+
188	+	## Suche nächste / vorhergehende Fundstelle des Wortes
189	+
190	+	Die zwei Funktionen sind im Kontextmenü des Quelltexteditors zu finden
191	+
192	+	- Quelltexteditor / Kontextmenü / Suchen / Nächste Fundstelle des Wortes
193	+	- Quelltexteditor / Kontextmenü / Suchen / Vorhergehende Fundstelle des Wortes
194	+
195	+	Und Sie können diesen Funktionen in den Editoreinstellungen ein Tastenkürzel zuweisen.
196	+
197	+	## Codevervollständigung
198	+
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>.
200	+
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.
202	+
203	+	Codevervollständigung kombiniert verschiedene mächtige Funktionen. Beispiele:
204	+
205	+	- Class Completion: komplettiert Eigenschaften; fügt Methodenrümpfe, private Variablen und private Zugriffsmethoden hinzu
206	+	- Forward Procedure Completion: fügt Prozedurenrümpfe hinzu
207	+	- Event Assignment Completion: komplettiert Ereigniszuweisungen; fügt Methodendefinition und -rumpf hinzu
208	+	- Variable Declaration Completion: fügt lokale Variablendefinitionen hinzu
209	+	- Reversed Class Completion: fügt Methoden-Deklarationen für Methodenrümpfe hinzu
210	+	- Procedure Call Completion: fügt eine neue Prozedur hinzu
211	+	- Reversed procedure completion: fügt Deklarationen für Prozedur-/Funktionsrümpfe hinzu
212	+
213	+	Welche Funktion genutzt wird, hängt von der Kursorposition im Editor ab und wird unten beschrieben.
214	+
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>.
216	+
217	+	### Class Completion
218	+
219	+	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.
220	+
221	+	Zum Beispiel: Erzeugen Sie eine Klasse (siehe Code-Schablonen, um einige Tipparbeit zu sparen):
222	+
223	+	``` pascal
224	+	TExample = class(TObject)
225	+	public
226	+	constructor Create;
227	+	destructor Destroy; override;
228	+	end;
229	+	```
230	+
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:
232	+
233	+	``` pascal
234	+	{ TExample }
235	+
236	+	constructor TExample.Create;
237	+	begin
238	+	\|
239	+	end;
240	+
241	+	destructor TExample.Destroy;
242	+	begin
243	+	inherited Destroy;
244	+	end;
245	+	```
246	+
247	+	Anmerkung: Das '\\|' ist der Kursor und nicht hinzugefügt.
248	+
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>.
250	+
251	+	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.
252	+
253	+	Jetzt fügen Sie eine Methode DoSomething hinzu:
254	+
255	+	``` pascal
256	+	TExample = class(TObject)
257	+	public
258	+	constructor Create;
259	+	procedure DoSomething(i: integer);
260	+	destructor Destroy; override;
261	+	end;
262	+	```
263	+
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:
265	+
266	+	``` pascal
267	+	procedure TExample.DoSomething(i: integer);
268	+	begin
269	+	\|
270	+	end;
271	+	```
272	+
273	+	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.
274	+
275	+	Complete Properties\
276	+	Fügen Sie eine Eigenschaft 'AnInteger' hinzu:
277	+
278	+	``` pascal
279	+	TExample = class(TObject)
280	+	public
281	+	constructor Create;
282	+	procedure DoSomething(i: integer);
283	+	destructor Destroy; override;
284	+	property AnInteger: Integer;
285	+	end;
286	+	```
287	+
288	+	Drücken Sie <span class="kbd">Ctrl</span>+<span class="kbd">Shift</span>+<span class="kbd">C</span> und Sie erhalten:
289	+
290	+	``` pascal
291	+	procedure TExample.SetAnInteger(const AValue: integer);
292	+	begin
293	+	\|if FAnInteger=AValue then exit;
294	+	FAnInteger:=AValue;
295	+	end;
296	+	```
297	+
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:
299	+
300	+	``` pascal
301	+	TExample = class(TObject)
302	+	private
303	+	FAnInteger: integer;
304	+	procedure SetAnInteger(const AValue: integer);
305	+	public
306	+	constructor Create;
307	+	procedure DoSomething(i: integer);
308	+	destructor Destroy; override;
309	+	property AnInteger: integer read FAnInteger write SetAnInteger;
310	+	end;
311	+	```
312	+
313	+	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.
314	+
315	+	Erzeugen einer Eigenschaft 'read only':
316	+
317	+	``` pascal
318	+	property PropName: PropType read;
319	+	```
320	+
321	+	wird erweitert zu
322	+
323	+	``` pascal
324	+	property PropName: PropType read FPropName;
325	+	```
326	+
327	+	Erzeugen einer Eigenschaft 'write only':
328	+
329	+	``` pascal
330	+	property PropName: PropType write;
331	+	```
332	+
333	+	wird erweitert zu
334	+
335	+	``` pascal
336	+	property PropName: PropType write SetPropName;
337	+	```
338	+
339	+	Erzeugen einer Eigenschaft 'read only' mit einer Read-Methode:
340	+
341	+	``` pascal
342	+	property PropName: PropType read GetPropName;
343	+	```
344	+
345	+	wird beibehalten und eine Funktion 'GetPropName' wird angefügt:
346	+
347	+	``` pascal
348	+	function GetpropName: PropType;
349	+	```
350	+
351	+	Erzeugen einer Eigenschaft mit einem stored-Modifizierer:
352	+
353	+	``` pascal
354	+	property PropName: PropType stored;
355	+	```
356	+
357	+	wird erweitert zu
358	+
359	+	``` pascal
360	+	property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;
361	+	```
362	+
363	+	Weil 'stored' für das Streaming benutzt wird, werden automatisch auch die read- und write-Modifizierer angefügt.
364	+
365	+	Hinweis: Die Bezeichnervervollständigung erkennt auch unvollständige Eigenschaften und wird die Standardnamen vorschlagen. Zum Beispiel:
366	+
367	+	``` pascal
368	+	property PropName: PropType read \|;
369	+	```
370	+
371	+	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.
372	+
373	+	### Forward Procedure Completion
374	+
375	+	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.
376	+
377	+	Zum Beispiel: Fügen Sie eine neue Prozedur zum Interface-Abschnitt hinzu:
378	+
379	+	``` pascal
380	+	procedure DoSomething;
381	+	```
382	+
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:
384	+
385	+	``` pascal
386	+	procedure DoSomething;
387	+	begin
388	+	\|
389	+	end;
390	+	```
391	+
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>.
393	+
394	+	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:
395	+
396	+	``` pascal
397	+	procedure Proc1;
398	+	procedure Proc2; // neue Prozedur
399	+	procedure Proc3;
400	+	```
401	+
402	+	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.
403	+
404	+	Mehrere Prozeduren:
405	+
406	+	``` pascal
407	+	procedure Proc1_Old; // Rumpf existiert
408	+	procedure Proc2_New; // Rumpf existiert nicht
409	+	procedure Proc3_New; // "
410	+	procedure Proc4_New; // "
411	+	procedure Proc5_Old; // Rumpf existiert
412	+	```
413	+
414	+	Die Codevervollständigung wird alle 3 Prozedurrümpfe hinzufügen (Proc2_New, Proc3_New, Proc4_New).
415	+
416	+	Warum wird das Forward Procedure Completion genannt?
417	+
418	+	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.
419	+
420	+	### Event Assignment Completion
421	+
422	+	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.
423	+
424	+	Zum Beispiel: In einer Methode, sagen wir dem FormCreate Ereignis, fügen wir eine Zeile 'OnPaint:=' hinzu:
425	+
426	+	``` pascal
427	+	procedure TForm1.Form1Create(Sender: TObject);
428	+	begin
429	+	OnPaint:=\|
430	+	end;
431	+	```
432	+
433	+	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
434	+
435	+	``` pascal
436	+	OnPaint:=@Form1Paint;
437	+	```
438	+
439	+	Eine neue Methode Form1Paint wird zur Klasse TForm1 hinzugefügt. Dann wird die class completion gestartet und Sie erhalten:
440	+
441	+	``` pascal
442	+	procedure TForm1.Form1Paint(Sender: TObject);
443	+	begin
444	+	\|
445	+	end;
446	+	```
447	+
448	+	Das funktioniert wie das Hinzufügen von Methoden im Objektinspektor.
449	+
450	+	Anmerkung:\
451	+	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.
452	+
453	+	Hinweis:\
454	+	Sie können den neuen Methodennamen selbst definieren. Zum Beispiel:
455	+
456	+	``` pascal
457	+	OnPaint:=@ThePaintMethod;
458	+	```
459	+
460	+	### Variable Declaration Completion
461	+
462	+	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.
463	+
464	+	Zum Beispiel:
465	+
466	+	``` pascal
467	+	procedure TForm1.Form1Create(Sender: TObject);
468	+	begin
469	+	i:=3;
470	+	end;
471	+	```
472	+
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:
474	+
475	+	``` pascal
476	+	procedure TForm1.Form1Create(Sender: TObject);
477	+	var
478	+	i: Integer;
479	+	begin
480	+	i:=3;
481	+	end;
482	+	```
483	+
484	+	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.
485	+
486	+	Ein anderes Beispiel:
487	+
488	+	``` pascal
489	+	type
490	+	TWhere = (Behind, Middle, InFront);
491	+
492	+	procedure TForm1.Form1Create(Sender: TObject);
493	+	var
494	+	a: array[TWhere] of char;
495	+	begin
496	+	for Where:=Low(a) to High(a) do writeln(a[Where]);
497	+	end;
498	+	```
499	+
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:
501	+
502	+	``` pascal
503	+	procedure TForm1.Form1Create(Sender: TObject);
504	+	var
505	+	a: array[TWhere] of char;
506	+	Where: TWhere;
507	+	begin
508	+	for Where:=Low(a) to High(a) do writeln(a[Where]);
509	+	end;
510	+	```
511	+
512	+	Seit Version 0.9.11 komplettiert Lazarus auch Parameter. Zum Beispiel
513	+
514	+	``` pascal
515	+	procedure TForm1.FormPaint(Sender: TObject);
516	+	begin
517	+	with Canvas do begin
518	+	Line(x1,y1,x2,y2);
519	+	end;
520	+	end;
521	+	```
522	+
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:
524	+
525	+	``` pascal
526	+	procedure TForm1.FormPaint(Sender: TObject);
527	+	var
528	+	x1: integer;
529	+	begin
530	+	with Canvas do begin
531	+	Line(x1,y1,x2,y2);
532	+	end;
533	+	end;
534	+	```
535	+
536	+	### Procedure Call Completion
537	+
538	+	Die Codevervollständigung kann auch eine neue Prozedur aus dem Prozeduraufruf selbst erzeugen.
539	+
540	+	Angenommen, Sie haben gerade die Anweisung "DoSomething(Width);" geschrieben
541	+
542	+	``` pascal
543	+	procedure SomeProcedure;
544	+	var
545	+	Width: integer;
546	+	begin
547	+	Width:=3;
548	+	DoSomething(Width);
549	+	end;
550	+	```
551	+
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:
553	+
554	+	``` pascal
555	+	procedure DoSomething(aWidth: LongInt);
556	+	begin
557	+
558	+	end;
559	+
560	+	procedure SomeProcedure;
561	+	var
562	+	Width: integer;
563	+	begin
564	+	Width:=3;
565	+	DoSomething(Width);
566	+	end;
567	+	```
568	+
569	+	Es werden derzeit noch keine Funktionen oder Methoden erzeugt.
570	+
571	+	### Reversed Class Completion
572	+
573	+	"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.
574	+
575	+	Zum Beispiel:
576	+
577	+	``` pascal
578	+	procedure TForm1.DoSomething(Sender: TObject);
579	+	begin
580	+	end;
581	+	```
582	+
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.
584	+
585	+	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.
586	+
587	+	### Kommentare und Codevervollständigung
588	+
589	+	Die Codevervollständigung versucht die Kommentare dort zu behalten, wo sie hingehören. Zum Beispiel:
590	+
591	+	``` pascal
592	+	FList: TList; // list of TComponent
593	+	FInt: integer;
594	+	```
595	+
596	+	Wenn eine neue Variable zwischen FList und FInt eingesetzt wird, dann wird der Kommentar in der FList Zeile beibehalten. Das selbe gilt für
597	+
598	+	``` pascal
599	+	FList: TList; { list of TComponent
600	+	Dies ist ein Kommentar über mehrere Zeilen, beginnend
601	+	in der FList-Zeile. Die CodeTools nehmen an, er gehöre
602	+	zu der FList-Zeile und brechen diese Beziehung nicht
603	+	auf. Der Code wird hinter dem Kommentar eingefügt. }
604	+	FInt: integer;
605	+	```
606	+
607	+	Wenn der Kommentar in der nächsten Zeile startet, dann wird er behandelt, wie wenn er zum nachfolgenden Code gehört. Zum Beispiel:
608	+
609	+	``` pascal
610	+	FList: TList; // list of TComponent
611	+	{ Dieser Kommentar gehört zur nachfolgenden Anweisung.
612	+	Neuer Code wird oberhalb des Kommentars eingefügt und
613	+	hinter dem Kommentar der FList-Zeile. }
614	+	FInt: integer;
615	+	```
616	+
617	+	### Method update
618	+
619	+	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.
620	+
621	+	``` pascal
622	+	public
623	+	procedure DoSomething;
624	+	end;
625	+
626	+	procedure TForm.DoSomething;
627	+	begin
628	+	end;
629	+	```
630	+
631	+	Fügen Sie jetzt einen Parameter hinzu:
632	+
633	+	``` pascal
634	+	public
635	+	procedure DoSomething(i: integer);
636	+	end;
637	+	```
638	+
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:
640	+
641	+	``` pascal
642	+	procedure TForm.DoSomething(i: integer);
643	+	begin
644	+	end;
645	+	```
646	+
647	+	## Refactoring
648	+
649	+	### Invert Assignments
650	+
651	+	Kurz gefasst
652	+	"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.
653	+
654	+	Beispiel:\
655	+
656	+	``` pascal
657	+	procedure DoSomething;
658	+	begin
659	+	AValueStudio:= BValueStudio;
660	+	AValueAppartment :=BValueAppartment;
661	+	AValueHouse:=BValueHouse;
662	+	end;
663	+	```
664	+
665	+	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:
666	+
667	+	Resultat:
668	+
669	+	``` pascal
670	+	procedure DoSomething;
671	+	begin
672	+	BValueStudio := AValueStudio;
673	+	BValueAppartment := AValueAppartment;
674	+	BValueHouse := AValueHouse;
675	+	end;
676	+	```
677	+
678	+	### Enclose Selection
679	+
680	+	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.
681	+
682	+	### Bezeichner umbenennen
683	+
684	+	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.
685	+
686	+	- 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.
687	+	- Und es wird zuerst auf Namenskonflikte überprüft.
688	+	- Beschränkungen: Das funktioniert nur mit Pascal-Quellen, benennt keine Dateinamen um und bearbeitet weder lfm/lrs-Dateien noch lazdoc-Dateien.
689	+
690	+	### Find Identifier References
691	+
692	+	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.
693	+
694	+	### Show abstract methods
695	+
696	+	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.
697	+
698	+	### Prozedur extrahieren
699	+
700	+	Siehe [[IDE Window: Extract Procedure\|Prozedur extrahieren]]
701	+
702	+	## Find Declaration
703	+
704	+	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.
705	+
706	+	Jede find declaration setzt einen Sprungpunkt. Das bedeutet, Sie springen mit find declaration zur Deklaration und einfach zurück mit Suche -\> Zurückspringen.
707	+
708	+	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:
709	+
710	+	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.
711	+
712	+	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
713	+
714	+	``` pascal
715	+	TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;
716	+	TColor = TGraphicsColor;
717	+	```
718	+
719	+	Und das selbe für forward defined classes: Zum Beispiel gibt es in TControl eine private Variable
720	+
721	+	``` pascal
722	+	FHostDockSite: TWinControl;
723	+	```
724	+
725	+	Find declaration auf TWinControl springt zur forward definition
726	+
727	+	``` pascal
728	+	TWinControl = class;
729	+	```
730	+
731	+	Und ein erneuter Aufruf springt zur realen Implementierung
732	+
733	+	``` pascal
734	+	TWinControl = class(TControl)
735	+	```
736	+
737	+	Auf diese Weise können Sie jeden Bezeichner aufspüren und jede Überladung finden.
738	+
739	+	Tipps:
740	+
741	+	- Sie können zurück springen mit <span class="kbd">Strg</span>+<span class="kbd">H</span>.
742	+	- Sie können alle besuchten Orte anzeigen/erreichen mittels Menü: Ansicht / Sprungliste anzeigen ...
743	+	- Mit einer 5-Tasten-Maus können Sie die beiden Extratasten dazu verwenden, vorwärts/rückwärts zu den besuchten Orten zu gehen
744	+
745	+
746	+	(Sie können die Tastenbelegung ändern mit Menü: Einstellungen / Maus / Erweitert
747	+
748	+	Siehe auch: [[IDE Window: EditorMouseOptionsAdvanced\|advanced mouse options]])
749	+
750	+	## Bezeichner-Vervollständigung
751	+
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:
753	+
754	+	``` pascal
755	+	procedure TForm1.FormCreate(Sender: TObject);
756	+	begin
757	+	\|
758	+	end;
759	+	```
760	+
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.
762	+
763	+	Anmerkung für Delphianer: Delphi nennt das Code completion.
764	+
765	+	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.
766	+
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.
768	+
769	+	Die Bezeichner-Vervollständigung zeigt sogar solche Bezeichner an, die inkompatibel sind.
770	+
771	+	### Präfix
772	+
773	+	Sie könne die Bezeichner-Vervollständigung mitten in einem Wort starten. Dann werden die Buchstaben links als Präfix genommen. Zum Beispiel:
774	+
775	+	``` pascal
776	+	procedure TForm1.FormCreate(Sender: TObject);
777	+	begin
778	+	Ca\|ption
779	+	end;
780	+	```
781	+
782	+	Die Suchliste zeigt Ihnen dann nur diejenigen Bezeichner an, die mit 'Ca' beginnen.
783	+
784	+	### Tasten
785	+
786	+	- Buchstabe oder Ziffer: füge das Zeichen hinzu im Quelltexteditor und im aktuellen Präfix. Dadurch wird die Liste aktualisiert.
787	+	- Backspace: entfernt das letzte Zeichen aus dem Quelltexteditor und dem Präfix. Aktualisiert die Liste.
788	+	- Eingabe: ersetzt das ganze Wort am Kursor mit dem ausgewählten Bezeichner und schließt das Popup-Fenster.
789	+	- Umschalt+Eingabe: wie Eingabe, aber ersetzt nur das Präfix (linker Teil) des Wortes am Kursor.
790	+	- Nach oben/Nach unten: bewegt die Auswahl
791	+	- Escape: schließt das Popup-Fenster ohne Änderungen
792	+	- 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.
793	+	- Else: wie Eingabe und fügt das Zeichen zum Quelltexteditor hinzu
794	+
795	+	### Methoden
796	+
797	+	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:
798	+
799	+	``` pascal
800	+	TMainForm = class(TForm)
801	+	protected
802	+	mous\|
803	+	end;
804	+	```
805	+
806	+	Die Vervollständigung von MouseDown ergibt:
807	+
808	+	``` pascal
809	+	TMainForm = class(TForm)
810	+	protected
811	+	procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X,
812	+	Y: Integer); override;
813	+	end;
814	+	```
815	+
816	+	### Eigenschaften
817	+
818	+	``` pascal
819	+	property MyInt: integer read \|;
820	+	```
821	+
822	+	Die Bezeichner-Vervollständigung zeigt Ihnen FMyInt und GetMyInt.
823	+
824	+	``` pascal
825	+	property MyInt: integer write \|;
826	+	```
827	+
828	+	Die Bezeichner-Vervollständigung zeigt Ihnen FMyInt und SetMyInt.
829	+
830	+	### Uses-Abschnitt / Unitnamen
831	+
832	+	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).
833	+
834	+	### Anweisungen
835	+
836	+	``` pascal
837	+	procedure TMainForm.Button1Click(Sender: TObject);
838	+	begin
839	+	ModalRe\|;
840	+	end;
841	+	```
842	+
843	+	wird zu:
844	+
845	+	``` pascal
846	+	procedure TMainForm.Button1Click(Sender: TObject);
847	+	begin
848	+	ModalResult:=\|;
849	+	end;
850	+	```
851	+
852	+	## Wortvervollständigung
853	+
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.
855	+
856	+	Ansonsten funktioniert sie genau gleich wie die Bezeichner-Vervollständigung.
857	+
858	+	## Zu Include-Anweisung springen
859	+
860	+	"Zu Include-Anweisung springen" im Menü 'Suchen' der IDE springt zur {\$I filename} Anweisung, wo die aktuelle Include-Datei verwendet wird.
861	+
862	+	## Projekt veröffentlichen
863	+
864	+	Erzeugt eine Kopie des gesamten Projekts. Wenn Sie jemandem einfach die Quellen und Kompilereinstellungen Ihres Codes senden wollen, dann ist diese Funktion Ihr Freund.
865	+
866	+	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".
867	+
868	+	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.
869	+
870	+	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.
871	+
872	+	## Tipps von Kommentaren
873	+
874	+	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:
875	+
876	+	### Kommentare im Tipp angezeigt
877	+
878	+	Kommentare vor einer Deklaration, ohne Leerzeile und nicht mit dem \<-Zeichen beginnend:
879	+
880	+	``` pascal
881	+	var
882	+	{Comment}
883	+	Identifier: integer;
884	+	```
885	+
886	+	Kommentare mit dem \<-Zeichen gehören zum vorhergehenden Bezeichner.
887	+
888	+	Kommentare hinter einem Bezeichner in der selben Zeile:
889	+
890	+	``` pascal
891	+	var
892	+	identifier, // Comment
893	+	other,
894	+	```
895	+
896	+	Kommentare hinter der Definition in der selben Zeile:
897	+
898	+	``` pascal
899	+	var
900	+	identifier:
901	+	char; // Comment
902	+	```
903	+
904	+	Ein Beispiel für das \<-Zeichen:
905	+
906	+	``` pascal
907	+	const
908	+	a = 1;
909	+	//< comment for a
910	+	b = 2;
911	+	// comment for c
912	+	c = 3;
913	+	```
914	+
915	+	Alle drei Kommentartypen werden unterstützt:
916	+
917	+	``` pascal
918	+	{Comment}(Comment)//Comment
919	+	c = 1;
920	+	```
921	+
922	+	Kommentare, die mit \$ und % beginnen, werden ignoriert.
923	+
924	+	### Kommentare, nicht im Tipp angezeigt
925	+
926	+	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:
927	+
928	+	``` pascal
929	+	type
930	+	{ TMyClass }
931	+
932	+	TMyClass = class
933	+	```
934	+
935	+	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.
936	+
937	+	Der folgende Kommentar wird angezeigt für GL_TRUE, aber nicht für GL_FALSE:
938	+
939	+	``` pascal
940	+	// Boolean
941	+	GL_TRUE = 1;
942	+	GL_FALSE = 0;
943	+	```
944	+
945	+	---
946	+	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