Lazarus IDE Tools/nl: what changed

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

Old	New		Line
1	1		## Overzicht
2	2
3	3		De IDE gebruikt een verzameling tools voor het "parsen" (uit elkaar pluizen) van de source code en bewerken van tekst, de zogenaamde "codetools". Deze tools bieden functionaliteiten als het vinden van een declaratie, code completion en allerlei andere code bewerkingsfuncties. Deze tools kunnen je een hoop tijd en dubbel werk besparen. Je kunt ze helemaal naar eigen inzicht inrichten en iedere functies is bereikbaar via een "short cut" (Zie de Editor Options!).
4	4
5	5		De tools werken alleen met source code en begrijpen de verschillende Pascal varianten (FPC, Delphi en Kylix) dus zijn gecompileerde units of een compiler niet nodig. Je kunt tegelijkertijd Delphi en FPC code bewerken en zelfs met verschillende Delphi en FPC versies tegelijkertijd. Hierdoor wordt het overzetten van Delphi code naar Lazarus nog makkelijker.
6	6
7	7		## Ovezicht van IDE shortcuts
8	8
9	9		\| \| \|
10	10		\|----\|----\|
11	11		\| Method Jumping \| Ctrl+Shift+Up (Schakelt tussen de definitie en the implementatie van een method) \|
12	12		\| Code Templates \| Ctrl+J \|
13	13		\| Code Completion (Class Completion) \| Ctrl+Shift+C \|
14	14		\| Identifier Completion \| Ctrl+Space \|
15	15
16	16		## Method Jumping
17	17
18	18		Om te springen van de definitie van een procedure (of function) naar de implementatie hiervan kun je Ctrl+Shift+Up gebruiken.
19	19
20	20		Bijvoorbeeld:
21	21
22	22		`interface`\
23		-	\
	23	+
24	24		`procedure DoSomething; // procedure definition`\
25	25		` `\
26	26		`implementation`\
27	27		` `\
28	28		`procedure DoSomething; // procedure body `\
29	29		`begin`\
30	30		`end;`
31	31
32	32		Als de cursor ergens in de procedure "body" staat en je geeft Ctrl+Shift+Up, dan zal de cursor naar de definitie van de procedure springen. Druk je nogmaals op Ctrl+Shift+Up dan gaat de cursor weer naar de implementatie van de procedure net achter de eerste 'begin'.
33	33
34	34		Dit werkt natuurlijk ook bij methods (procedures van een classe).
35	35
36	36		Hint: 'Method Jumping' springt naar de procedure met dezelfde naam en parameter lijst. Als er echter geen procedure gevonden kan worden die precies gelijk is, wordt er gesprongen naar een procedure die het meest overeenkomt, de cursor wordt dan geplaatst op het punt waar de eerste afwijking is gevonden, in Delphi gebeurt dit helaas niet. Dit kan handig zijn bij het wijzigen van de parameterlijst.
37	37
38	38		Bijvoorbeeld een procedure met een andere parameterlijst:
39	39
40	40		`interface`\
41		-	\
	41	+
42	42		`procedure DoSomething(p: char); // procedure definition`\
43		-	\
	43	+
44	44		`implementation`\
45	45		` `\
46	46		`procedure DoSomething(p: string); // procedure body`\
47	47		`begin`\
48	48		`end;`
49	49
50	50		Hier zal de cursor dus geplaatst worden voor 'string' als er gebruik gemaakt wordt van Method Jumping. Ook het wijzigen van een procedure naam is hiermee eenvoudiger:
51	51
52	52		Bijvoorbeeld:\
53	53		Je hebt de procedure 'DoSomething' hernoemd naar 'MakeIt':
54	54
55	55		`interface`\
56		-	\
	56	+
57	57		`procedure MakeIt; // procedure definition`\
58		-	\
	58	+
59	59		`implementation`\
60		-	\
	60	+
61	61		`procedure DoSomething; // procedure body`\
62	62		`begin`\
63	63		`end;`
64	64
65	65		Als je dan op ctrl+shift+C drukt, zal de IDE beginnen met zoeken naar de juiste body. Omdat het die niet exact kan vinden zal het gaan zoeken naar een andere geschikte kandidaat. Omdat je maar een procudure wijzigde zal de oude DoSomething procedure de enige zijn zonder een definitie en zal de IDE hiernaar toe springen en de cursor plaatsen voor 'DoSomething'.
66	66
67	67		## Include Files
68	68
69	69		Met behulp van de {\$I bestandsnaam} directive kunnen bestanden als onderdeel van de source worden opgenomen. Lazarus en FPC maken erg veel gebruik van deze zogenaamde "Include files", omdat ze de code leesbaarder houden en de code redundancy verminderen. De leesbaarheid wordt verhoogt doordat er geen onoverzichtelijke {\$IFDEF} constructies gebruikt hoeven worden voor de ondersteuning van meerdere platforms.
70	70
71	71		De Lazarus IDE kent een goede ondersteuning van het gebruik van include files. Als bijvoorbeeld de implementatie van een Unit in een inlcude file is opgenomen, zal het springen van de definitie naar de implementatie ook dan goed gaan en de IDE zal dus de include file openen en daar de implementatie van de procedure vinden!
72	72
73	73		Ook code completion houdt hier rekening mee. Als de implementatie van een classe in een Include file is geplaatst zal het toevoegen van een method in de definitie, de automatisch implementatie (ctrl+shift+C) ook in de include file plaatsen. Je kunt dus de volledige implementatie van ee class in een include file doen. (Dit is in Lazarus eigenlijk altijd zo gedaan.)
74	74
75	75		Pas op! Als wel de include file is geopend met de implementatie van een classe zal Method Jumping of Find Decleration niet de unit openen waarin de include file is opgenomen. Dus altijd eerst de unit zelf openen en pas dan de include file met de implementatie.
76	76
77	77		De IDE analyseert de code en controleert daarbij de include directives. Voor later gebruik wordt de informatie over de relaties tussen units en include files opgeslagen in een bestand (includelinks.xml). Als je dan een volgende keer de include file opent zal de IDE bij een Find Declaration of een Method Jump weten welke unit geopend moet worden.
78	78
79	79		## Code Templates
80	80
81	81		"Code templates" zijn stukjes tekst die met een bepaalde toets-combinatie worden omgezet naar een stuk code.
82	82
83	83		De standaard toets-combinatie voor Code Templates is Ctrl+J. De stukjes tekst (templates) definieer je via Environment -\> Editor Options -\> CodeTools. Voor het gebruik ervan tik je dan de tekst gevolgd door ctrl+J.
84	84
85	85		Bijvoorbeeld: Als je 'classf' intikt, de cursor achter de f laat staan en dan op Ctrl+J drukt, zal 'classf' worden vervangen door
86	86
87	87		`T = class(T)`\
88	88		`private`\
89		-	\
	89	+
90	90		`public`\
91	91		` constructor Create;`\
92	92		` destructor Destroy; override;`\
93	93		`end;`
94	94
95	95		waarbij de cursor achter de eerste T staat.
96	96
97	97		Je kunt ook in de IDE een lijst met templates op vragen door de cursor op een lege plek te plaatsen en dan op ctrl+J te drukken. Er zal dan een popup veschijnen met een lijst van de beschikbare templates. Door het gebruik van de pijltjes-toetsen of door het intikken van een aantal letters kun je een keuze maken. Deze keuze bevestig je dan met Enter waarbij de gekozen template wordt uitgevoerd. Zoals gewoonlijk kun je met ESC de popup sluiten, zonder dat er een template wordt uitgevoerd.
98	98
99	99		## Code Completion
100	100
101	101		Code Completion kan via het menu (Edit -\> Complete Code) of via de short cut Ctrl+Shift+C opgeroepen woden.
102	102
103	103		Verschil met Delphi: De functionaliteit die in Delphi "Code Completion" heet, is in Lazarus opgenomen als "Identifier completion". Deze functie wordt in beide omgevingen opgeroepen met Ctrl+Spatie.
104	104
105	105		Code completion kent een aantal varianten:
106	106
107	107		- Class Completion: completes properties, adds method bodies, add private variables and private access methods
108	108		- Forward Procedure Completion: adds procedure bodies
109	109		- Event Assignment Completion: completes event assignments and adds method definition and body
110	110		- Local Variable Completion: adds local variable definitions
111	111
112	112		Welke variant wordt opgeroepen is afhankelijk van de cursor positie in de Editor.
113	113
114	114		### Class Completion
115	115
116	116		Class completion is de meest veelzijdige functie. Je schrijft een class en voegt de methodes en properties toe en Code Completion zal de methode implementaties, de methodes voor het lezen en schrijven van de properties en de bijbehorende private vrariabelen voor je toevoegen.
117	117
118	118		Bijvoorbeeld. Definieer een class (Gebruik de code templates om je wat tikwerk te besparen):
119	119
120	120		`TExample = class(TObject)`\
121	121		`public`\
122	122		` constructor Create;`\
123	123		` destructor Destroy; override;`\
124	124		`end;`
125	125
126	126		Zet daarna de cursor ergens in deze tekst en druk op Ctrl+Shift+C. Het gevolg zal zijn dat in de implementatie sectie van je unit de volgende tekst is verschenen, zodat je gelijk verder kunt met het schrijven van de Create method::
127	127
128	128		`{ TExample }`\
129		-	\
	129	+
130	130		`constructor TExample.Create;`\
131	131		`begin`\
132	132		` \|`\
133	133		`end;`\
134		-	\
	134	+
135	135		`destructor TExample.Destroy;`\
136	136		`begin`\
137	137		` inherited Destroy;`\
138	138		`end;`
139	139
140	140		Let op: De '\\|' geeft hier de plaats van de cursor aan!
141	141
142	142		Hint: Zoals we gezien hebben kunnen je met Ctrl+Shift+Up heen en weer schakelen tussen de definitie en de implementatie.
143	143
144		-	Zoals je ziet heeft de IDE ook een aanroep naar 'inherited Destroy' toegevoegd. Dit gebeurt als een methode met <b>override</b> is gedefinieerd in de ancestor (de class waar jouw class van is afgeleid).
	144	+	Zoals je ziet heeft de IDE ook een aanroep naar 'inherited Destroy' toegevoegd. Dit gebeurt als een methode met override is gedefinieerd in de ancestor (de class waar jouw class van is afgeleid).
145	145
146	146		Voeg nu de method DoSomething toe aan de class definitie:
147	147
148	148		`TExample = class(TObject)`\
149	149		`public`\
150	150		` constructor Create;`\
151	151		` procedure DoSomething(i: integer);`\
152	152		` destructor Destroy; override;`\
153	153		`end;`
154	154
155	155		en druk op Ctrl+Shift+C. De IDE zal het volgende toevoegen
156	156
157	157		`procedure TExample.DoSomething(i: integer);`\
158	158		`begin`\
159	159		` \|`\
160	160		`end;`
161	161
162	162		Afhankelijk van de door jouw ingestelde voorkeur wordt deze methode toegevoegd tussen Create and Destroy zoals in de class definitie of op alfabetische volgorde. Deze voorkeur kun je instellen in Environment \> Codetools Options -\> Code Creation.
163	163
164	164		Complete Properties\
165	165		Voeg een property toe aan de class:
166	166
167	167		`TExample = class(TObject)`\
168	168		`public`\
169	169		` constructor Create;`\
170	170		` procedure DoSomething(i: integer);`\
171	171		` destructor Destroy; override;`\
172	172		` property AnInteger: Integer;`\
173	173		`end;`
174	174
175	175		Druk op Ctrl+Shift+C en het volgende wordt in de implementatie sectie toegevoegd:
176	176
177	177		`procedure TExample.SetAnInteger(const AValue: integer);`\
178	178		`begin`\
179	179		` \|if FAnInteger=AValue then exit;`\
180	180		` FAnInteger:=AValue;`\
181	181		`end;`
182	182
183	183		Code completion heeft een Schrijf methode toegevoegd en daarin wat algemene code gezet. Maar dat is niet het enige! Druk op Ctrl+Shift+Up om terug te keren naar de class definitie en zie wat daar is gewijzigd:
184	184
185	185		`TExample = class(TObject)`\
186	186		`private`\
187	187		` FAnInteger: integer;`\
188	188		` procedure SetAnInteger(const AValue: integer);`\
189	189		`public`\
190	190		` constructor Create;`\
191	191		` procedure DoSomething(i: integer);`\
192	192		` destructor Destroy; override;`\
193	193		` property AnInteger: integer read FAnInteger write SetAnInteger;`\
194	194		`end;`
195	195
196	196		Het toegevoegde property is uitgebreid door aan te geven welke private variabele door dit property gelezen wordt en zoals gezegd de schrijf methode voor die variabele. We zien ook de nieuwe private sectie waarin deze variabele en de bijbehorende schrijfmethode (ook wel 'setter' genoemd) zijn opgenomen. Het is algemeen gebruikelijk om de naam van private variabelen vooraf te laten gaan door een 'F' en de schrijfmethode (setter) te laten beginnen met 'Set'. Mocht je dat anders willen dan kun je dit wijzigen in Environment \> Codetools Options -\> Code Creation.
197	197
198	198		Je kunt ook een "read only" property maken door:
199	199
200	200		`property PropName: PropType read;`
201	201
202	202		in te tikken. Als je dan Ctrl+Shift+C drukt wordt dit
203	203
204	204		`property PropName: PropType read FPropName;`
205	205
206	206		In theorie kun je een "write only" property maken door:
207	207
208	208		` property PropName: PropType write;`
209	209
210	210		in te tikken, wat dan door Code Completion wordt aangevuld tot
211	211
212	212		`property PropName: PropType write SetPropName;`
213	213
214	214		Het nut van een property dat je alleen kunt schrijven is mij niet helemaal duidelijk, maar het is dus mogelijk. Een "read only" property met een lees methode (ook wel 'Getter' genoemd):
215	215
216	216		`property PropName: PropType read GetPropName;`
217	217
218	218		Deze regel wordt dan niet veranderd, maar code completion zal wel de GetPropName function toevoegen:
219	219
220	220		`function GetpropName: PropType;`
221	221
222	222		Je kunt ook een property maken met een "stored" modifier:
223	223
224	224		`property PropName: PropType stored;`
225	225
226	226		dit zal worden uitgebreid door CodeCompletion tot:
227	227
228	228		`property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;`
229	229
230	230		De stored modifier bepaald of een property wordt opgeslagen met de form definitie. Als het niet is opgegeven wordt de waarde True aangenomen.
231	231
232	232		Tip: Identifier completion herkent ook incomplete properties en zal de standaard namen voorstellen. Dus bijvoorbeeld::
233	233
234	234		`property PropName: PropType read \|;`
235	235
236	236		Als de cursor een spatie achter 'read' staat en je drukt op Ctrl+Space dan krijg je een lijstje te zien met de variable 'FPropName' en de 'setter' 'SetPropName'.
237	237
238	238		### Forward Procedure Completion
239	239
240	240		"Forward Procedure Completion" is een onderdeel van de Code Completion en voegt procedure implementaties toe die missen. Dit onderdeel van Code Completion wordt opgeroepen als de cursor op een procedure definitie is geplaatst.
241	241
242	242		Bijvoorbeeld: Voeg een nieuwe procedure toe aan de interface sectie:
243	243
244	244		`procedure DoSomething;`
245	245
246	246		Zet de cursor er op en druk Ctrl+Shift+C. Er zal dan in de implementatie sectie een raamwerk voor de procedure worden gemaakt:
247	247
248	248		`procedure DoSomething;`\
249	249		`begin`\
250	250		` \|`\
251	251		`end;`
252	252
253	253		Tip: Ook hier kun je tussen de definitie en de implementatie heen en weer springen met Ctrl+Shift+Up.
254	254
255	255		Waar de nieuwe procedure implementatie wordt geplaatst is afhankelijk van de voorkeur zoals die is ingesteld in Environment \> Codetools Options -\> Code Creation. Als er al een aantal procedures zijn opgenomen, zal de IDE proberen de implementaties in dezelfde volgorde te zetten als de definities. Bijvoorbeeld:
256	256
257	257		` procedure Proc1;`\
258	258		` procedure Proc2; // Nieuw`\
259	259		` procedure Proc3;`
260	260
261	261		Als de implementaties van Proc1 en Proc3 al aanwezig zijn, zal de implementatie van Proc2 hier tussen geplaatst worden.
262	262
263	263		Meerdere procedures in een keer kan ook:
264	264
265	265		`procedure Proc1_Old; // Bestaat al, implementatie aanwezig.`\
266	266		`procedure Proc2_New; // Implementatie niet aanwezig.`\
267	267		`procedure Proc3_New; // "`\
268	268		`procedure Proc4_New; // "`\
269	269		`procedure Proc5_Old; // Bestaat al, implementatie aanwezig.`
270	270
271	271		In dit geval zullen er door Code Completion 3 procedure implementaties worden toegevoegd (Proc2_New, Proc3_New, Proc4_New).
272	272
273	273		Waarom heet dit nu "Forward Procedure Completion"? Eigenlijk heel simpel, omdat het ook werkt bij procedures die met de "forward" modifier zijn gedefinieerd!
274	274
275	275		### Event Assignment Completion
276	276
277	277		"Event Assignment Completion" is ook een onderdeel van de Code Completion en completeerd een
278	278
279	279		`Event := \|`
280	280
281	281		statement. Druk je nu op Ctrl+Shift+C zoals in het volgende voorbeeld:
282	282
283	283		`procedure TForm1.Form1Create(Sender: TObject);`\
284	284		`begin`\
285	285		` OnPaint:=\|`\
286	286		`end;`
287	287
288	288		De '\\|' is natuurlijk weer de plaats van de cursor! Als je nu op press Ctrl+Shift+C drukt het statement zal worden gecompleteerd tot:
289	289
290	290		`OnPaint:=@Form1Paint;`
291	291
292	292		In de definitie van TForm1 zal deze methode worden opgenomen en in de implementatie sectie zal het skelet van de procedure gezet worden:
293	293
294	294		`procedure TForm1.Form1Paint(Sender: TObject);`\
295	295		`begin`\
296	296		` \|`\
297	297		`end;`
298	298
299	299		Eigenlijk precies zo als bij het toevoegen van een methode in de Object Inspector.
300	300
301	301		Let op:\
302	302		De cursor moet achter de ':=' staan, omdat anders "Local Variable Completion" zal worden aangeroepen. Dit zal echter mislukken want OnPaint is immers al gedefinieerd.
303	303
304	304		Tip:\
305	305		Je kunt zelf de naam van de method bepalen door bijvoorbeeld:
306	306
307	307		` OnPaint:=@ThePaintMethod;`
308	308
309	309		te typen en daarna Ctrl+Shift+C te geven.
310	310
311	311		### Local Variable Completion
312	312
313	313		"Local Variable Completion" is het onderdeel van Code Completion dat een lokale variabele toevoegt voor een Identifier := Waarde; statement. Je kunt het oproepen als de cursor op de identifier staat.
314	314
315	315		Bijvoorbeeld:
316	316
317	317		`procedure TForm1.Form1Create(Sender: TObject);`\
318	318		`begin`\
319	319		` i:=3;`\
320	320		`end;`
321	321
322	322		Plaats de cursor op de 'i' of er net achter, druk dan op Ctrl+Shift+C en dit is het resultaat:
323	323
324	324		`procedure TForm1.Form1Create(Sender: TObject);`\
325	325		`var`\
326	326		` i: Integer;`\
327	327		`begin`\
328	328		` i:=3;`\
329	329		`end;`
330	330
331	331		Code Completion controleert eerst of de identifier 'i' al gedefinieerd is en zo niet dan zal het de declaratie 'var i: integer;' toevoegen. Het type van de identifier is gebaseerd op de toegekende waarde. Getallen worden standaard een Integer.
332	332
333	333		Een ander voorbeeld, die wat meer de ingebouwde intelligentie aantoont: type
334	334
335	335		` TWhere = (Behind, Middle, InFront);`\
336		-	\
	336	+
337	337		` procedure TForm1.Form1Create(Sender: TObject);`\
338	338		` var`\
339	339		` a: array[TWhere] of char;`\
340	340		` begin`\
341	341		` for Where:=Low(a) to High(a) do writeln(a[Where]);`\
342	342		` end;`
343	343
344	344		Plaats de cursor op 'Where' en druk op Ctrl+Shift+C. Je krijgt dan:
345	345
346	346		`procedure TForm1.Form1Create(Sender: TObject);`\
347	347		`var`\
348	348		` a: array[TWhere] of char;`\
349	349		` Where: TWhere;`\
350	350		`begin`\
351	351		` for Where:=Low(a) to High(a) do writeln(a[Where]);`\
352	352		`end;`
353	353
354	354		### Commentaar en Code Completion
355	355
356	356		Code Completion zal het commentaar zoveel mogelijk daar houden waar het hoort. Bij voorbeeld:
357	357
358	358		` FList: TList; // lijst van TComponent`\
359	359		` FInt: integer;`
360	360
361	361		Als er een nieuwe variabele tussen wordt gezet, zal het commentaar op de regel van FList blijven. Het zelfde geldt voor
362	362
363	363		` FList: TList; { lijst van TComponent`\
364	364		` Dit is commentaar over meerdere regels, dat begint`\
365	365		` op de FList regel, so Code Completion neemt aan dat `\
366	366		` het bij FList hoort en zal deze deze relatie niet`\
367	367		` verbreken. Nieuwe code wordt hierna geplaatst. }`\
368	368		` FInt: integer;`
369	369
370	370		Maar in het volgende voorbeeld:
371	371
372	372		` FList: TList; // list of TComponent`\
373	373		` { Dit commentaar behoort tot het volgende statement.`\
374	374		` Nieuwe code kan dus hierboven worden toegevoegd en`\
375	375		` na het commentaar van de FList regel. }`\
376	376		` FInt: integer;`
377	377
378	378		## Refactoring
379	379
380	380		### Invert Assignments
381	381
382	382		Samenvatting
383	383
384	384		"Invert Assignments" draait geselecteerde pascal statements om. Je kunt het gebruiken voor het omvormen van "bewaar" code naar "inlees" code.
385	385
386	386		Een voorbeeld zal een en ander wat duidelijker maken:\
387	387		procedure DoSomething;
388	388
389	389		`begin`\
390	390		` AValueStudio:= BValueStudio;`\
391	391		` AValueAppartment :=BValueAppartment;`\
392	392		` AValueHouse:=BValueHouse;`\
393	393		`end;`
394	394
395	395		Selecteer de regels met toekenningen (assignments) en kies dan voor "Invert Assignments". Dit vind je door rechts te klikken in de geselecteerde code en dan te kiezen voor "Refactoring". Alle toekennen zullen nu worden omgedraaid. Het resultaat ziet er dan als volgt uit:
396	396
397	397		`procedure DoSomething;`\
398	398		`begin`\
399	399		` BValueStudio := AValueStudio;`\
400	400		` BValueAppartment := AValueAppartment;`\
401	401		` BValueHouse := AValueHouse;`\
402	402		`end;`
403	403
404	404		### Extract Procedure
405	405
406	406		Samenvatting
407	407
408	408		"Extract Procedure" maakt van de geselecteerde code een nieuwe procedure. Dit is makkelijk bij het splitsen van een hele grote procedure in een aantal kleinere of het maken van een nieuwe procedure omdat de betreffende code op meerdere plaatsen gebruikt wordt. Extract procedure kun je oproepen via Edit -\> Extract Procedure of via Rechtermuisklik -\> Refactoring -\> Extract Procedure.
409	409
410	410		De basis:\
411	411		procedure DoSomething;
412	412
413	413		`begin`\
414	414		` Statement1;`\
415	415		` Statement2;`\
416	416		` Statement3;`\
417	417		`end;`
418	418
419	419		Selecteer de regels tussen begin en end. Kies dan voor Extract Procedure. Er zal dan een dialoog waarmee je het type procedure kunt kiezen en een naam voor de procedure kunt invoeren. Bijvoorbeeld: procedure, "NewProc". Result:
420	420
421	421		`procedure NewProc;`\
422	422		`begin`\
423	423		` Statement1;`\
424	424		` Statement2;`\
425	425		` Statement3;`\
426	426		`end;`\
427		-	\
	427	+
428	428		`procedure DoSomething;`\
429	429		`begin`\
430	430		` NewProc;`\
431	431		`end;`
432	432
433	433		Zoals je ziet is er een nieuwe procedure gemaakt "NewProc", met de geselecteerd statements en is de oorspronkelijke code vervangen door een aanroep van de nieuwe procedure. Had je voor het type "Private Method" gekozen, dan was er in de type definitie van je klasse in de private sectie een definitie van de nieuwe procedure gemaakt naast natuurlijk de implementatie van deze procedure.
434	434
435	435		Lokale Variabelen en Parameters:\
436	436		"Extract Procedure" zal automatisch de code scannen voor lokale variabele en deze aanmaken. Ook eventuele parameters worden automatisch aangemaakt. Bijvoorbeeld:
437	437
438	438		`procedure TForm1.DoSomething(var Ernie, Bert: integer);`\
439	439		`var`\
440	440		` I: Integer; // Commentaar`\
441	441		`begin`\
442	442		` Ernie:=Ernie+Bert;`\
443	443		` for I:=Ernie to 5 do begin`\
444	444		` \|`\
445	445		` end;`\
446	446		`end;`
447	447
448	448		Selecteer nu de for-loop selecteert en maak met behulp van "Extract Procedure" een nieuwe procedure "NewProc" aan. Omdat de variabele I alleen in de geselecteerde code wordt gebruikt, wordt deze naar de nieuwe procedure verplaatst. Ernie wordt echter ook nog in de resterende code gebruikt dus zal het een parameter worden.
449	449
450	450		Het resultaat:\
451	451		procedure NewProc(const Erni: integer);
452	452
453	453		`var`\
454	454		` i: Integer; // Commentaar`\
455	455		`begin`\
456	456		` for i:=Ernie to 5 do begin`\
457	457		` \|`\
458	458		` end;`\
459	459		`end;`\
460		-	\
	460	+
461	461		`procedure TForm1.DoSomething(var Erni, Bert: integer);`\
462	462		`begin`\
463	463		` Ernie:=Ernie+Bert;`\
464	464		` NewProc(Ernie);`\
465	465		`end;`
466	466
467	467		Zoals je ziet is de I in zijn geheel verplaatst naar de nieuwe procedure inclusief het bijbehorende commentaar.
468	468
469	469		Beperkingen:\
470	470		Omdat pascal een hoop mogelijkheden heeft, moet je niet verwachten dat het altijd even goed werkt. Huidige beperkingen en "ToDo"s:
471	471
472	472		- Controle op het overeenkomen van selectie grenzen met statement grenzen
473	473		- betere bepaling van het type van de parameters. Op het moment zijn parameters "const", als het "var" moeten zijn, moet je dat zelf wijzigen.
474	474		- "with" statements
475	475
476	476		## Find Declaration
477	477
478	478		Find Declaration kun je oproepen via Search -\> Find Declaration at cursor of via Rechtermuisklik -\> Find Declaration of via ctrl+muisklik. (In het laatste geval verschijnt er een lijn onder een identifier als de ctrl-toets is ingedrukt en de muiscursor komt boven de identifier. Hoe dan ook, de IDE gaat op zoek naar de declaratie van deze identifier, opent (indien nodig) de file en plaats de cursor op de regel waar de identifier is gedefinieerd.
479	479
480	480		Iedere zoek opdracht (Find Declaration) zorgt er voor dat er een Jump Point wordt gezet. Je kunt dus eenvoudig terug springen naar het punt waar je de zoek aktie heb gestart via Search -\> Jump back (ctrl+H).
481	481
482	482		De codetools houden rekening met de "normale" pascal regels. Hoewel de compiler alleen het laatste resultaat geeft, zien de codetools alle tussenliggende stappen. Bijvoorbeeld:
483	483
484	484		De 'Visible' property wordt voor het eerst gedefinieerd in TControl (controls.pp), later nog eens opnieuw in TCustomForm en uiteindelijk nog eens in TForm. Gebruik je dus Find Declaration op de Visible property van een Form, dan zal er eerst naar de definitie van TForm gesprongen worden, vandaar kun je dan springen naar de declaratie van TCustomForm en dan pas naar het visible property van TControl.
485	485
486	486		Iets soort gelijks geldt bijvoorbeeld voor TColor. Uiteindelijk is TColor niets anders dan een 'longint'. Maar in de sources is het als volgt gedefinieerd:
487	487
488	488		`TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;`\
489	489		`TColor = TGraphicsColor;`
490	490
491	491		Een voorbeeld van een 'forward' gedefinieerd control. In TControl is een private variabele gedefinieerd:
492	492
493	493		`FHostDockSite: TWinControl;`
494	494
495	495		Gebruik je in TControl Find declaration voor TWinControl, dan zal er naar de forward definitie gesprongen worden.
496	496
497	497		`TWinControl = class;`
498	498
499	499		Gebruik je hier dan nog eens de Find Declaratie, pas dan zal er naar de werkelijke definitie gesprongen worden:
500	500
501	501		`TWinControl = class(TControl)`
502	502
503	503		Het mag duidelijk zijn dat je op deze manier iedere identifier kunt opsporen en iedere overload terugvinden.
504	504
505	505		## Goto Include Directive
506	506
507	507		"Goto Include Directive" te vinden in het search menu van de IDE springt naar het {\$I filename} statement waar het huidige bestand wordt gebruikt.
508	508
509	509		## Publish Project
510	510
511	511		Maakt een kopie van je hele project. Als je iemand de code van je project wilt sturen is dit een handige functie. Ook voor het maken van een backup van je sources is dit natuurlijk uitermate geschikt.
512	512
513	513		In de project directory staat een helehoop informatie. Het meeste daarvan is niet strikt noodzakelijk voor het project, maar maken dat je als je het project opnieuw opent precies op dat punt bent waar je was bij het sluiten ervan. De .lpi file bevat deze sessie informatie (zoals de positie van de tekst cursor en bookmarks van gesloten units). Daarnaast staan er in de project directory een aantal .ppu en .o bestanden en natuurlijk de executable zelf. De .ppu en .o zijn tussenbestanden die gemaakt worden tijdens het compileren van je programma. Publish Project maakt dus een lpi file met de hoogstnodige informatie en plaatst deze met alle source files in een aparte subdirectory.
514	514
515	515		In de dialoog die verschijnt als je deze functie start kun je een filter opgeven van de bestanden die meegenomen moeten worden of juist niet. Met het "command after" zou je de bestanden eventueel direct in een zip of soortegelijk archief kunnen zetten.
516	516
517	517		---
518	518		From the Free Pascal wiki, page "Lazarus IDE Tools/nl", as it stood on 2010-01-30 after a change by Dataforger, 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