Sign in Join
Wiki copytemporary

Lazarus IDE Tools/nl: what changed

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

OldNewLine
11## Overzicht
22
33De 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!).
44
55De 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.
66
77## Ovezicht van IDE shortcuts
88
99| | |
1010|----|----|
1111| Method Jumping | Ctrl+Shift+Up (Schakelt tussen de definitie en the implementatie van een method) |
1212| Code Templates | Ctrl+J |
1313| Code Completion (Class Completion)   | Ctrl+Shift+C |
1414| Identifier Completion | Ctrl+Space |
1515
1616## Method Jumping
1717
1818Om te springen van de definitie van een procedure (of function) naar de implementatie hiervan kun je Ctrl+Shift+Up gebruiken.
1919
2020Bijvoorbeeld:
2121
22-`interface`\
22+``` pascal
23+interface
2324
24-`procedure DoSomething; // procedure definition`\
25-` `\
26-`implementation`\
27-` `\
28-`procedure DoSomething; // procedure body `\
29-`begin`\
30-`end;`
25+procedure DoSomething; // procedure definition
26+
27+implementation
28+
29+procedure DoSomething; // procedure body
30+begin
31+end;
32+```
3133
3234Als 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'.
3335
3436Dit werkt natuurlijk ook bij methods (procedures van een classe).
3537
3638Hint: '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.
3739
3840Bijvoorbeeld een procedure met een andere parameterlijst:
3941
40-`interface`\
42+``` pascal
43+interface
4144
42-`procedure DoSomething(p: char); // procedure definition`\
45+procedure DoSomething(p: char); // procedure definition
4346
44-`implementation`\
45-`  `\
46-`procedure DoSomething(p: string); // procedure body`\
47-`begin`\
48-`end;`
47+implementation
48+
49+procedure DoSomething(p: string); // procedure body
50+begin
51+end;
52+```
4953
5054Hier 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:
5155
5256Bijvoorbeeld:\
5357Je hebt de procedure 'DoSomething' hernoemd naar 'MakeIt':
5458
55-`interface`\
59+``` pascal
60+interface
5661
57-`procedure MakeIt; // procedure definition`\
62+procedure MakeIt; // procedure definition
5863
59-`implementation`\
64+implementation
6065
61-`procedure DoSomething; // procedure body`\
62-`begin`\
63-`end;`
66+procedure DoSomething; // procedure body
67+begin
68+end;
69+```
6470
6571Als 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'.
6672
6773## Include Files
6874
6975Met 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.
7076
7177De 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!
7278
7379Ook 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.)
7480
7581Pas 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.
7682
7783De 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.
7884
7985## Code Templates
8086
8187"Code templates" zijn stukjes tekst die met een bepaalde toets-combinatie worden omgezet naar een stuk code.
8288
8389De 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.
8490
8591Bijvoorbeeld: Als je 'classf' intikt, de cursor achter de f laat staan en dan op Ctrl+J drukt, zal 'classf' worden vervangen door
8692
87-`T = class(T)`\
88-`private`\
93+``` pascal
94+T = class(T)
95+private
8996
90-`public`\
91-`  constructor Create;`\
92-`  destructor Destroy; override;`\
93-`end;`
97+public
98+ constructor Create;
99+ destructor Destroy; override;
100+end;
101+```
94102
95103waarbij de cursor achter de eerste T staat.
96104
97105Je 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.
98106
99107## Code Completion
100108
101109Code Completion kan via het menu (Edit -\> Complete Code) of via de short cut Ctrl+Shift+C opgeroepen woden.
102110
103111Verschil 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.
104112
105113Code completion kent een aantal varianten:
106114
107115- **Class Completion**: completes properties, adds method bodies, add private variables and private access methods
108116- **Forward Procedure Completion**: adds procedure bodies
109117- **Event Assignment Completion**: completes event assignments and adds method definition and body
110118- **Local Variable Completion**: adds local variable definitions
111119
112120Welke variant wordt opgeroepen is afhankelijk van de cursor positie in de Editor.
113121
114122### Class Completion
115123
116124Class 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.
117125
118126Bijvoorbeeld. Definieer een class (Gebruik de code templates om je wat tikwerk te besparen):
119127
120-`TExample = class(TObject)`\
121-`public`\
122-`  constructor Create;`\
123-`  destructor Destroy; override;`\
124-`end;`
128+``` pascal
129+TExample = class(TObject)
130+public
131+ constructor Create;
132+ destructor Destroy; override;
133+end;
134+```
125135
126136Zet 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::
127137
128-`{ TExample }`\
138+``` pascal
139+{ TExample }
129140
130-`constructor TExample.Create;`\
131-`begin`\
132-`  |`\
133-`end;`\
141+constructor TExample.Create;
142+begin
143+ |
144+end;
134145
135-`destructor TExample.Destroy;`\
136-`begin`\
137-`  inherited Destroy;`\
138-`end;`
146+destructor TExample.Destroy;
147+begin
148+ inherited Destroy;
149+end;
150+```
139151
140152Let op: De '\|' geeft hier de plaats van de cursor aan!
141153
142154Hint: Zoals we gezien hebben kunnen je met Ctrl+Shift+Up heen en weer schakelen tussen de definitie en de implementatie.
143155
144156Zoals 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).
145157
146158Voeg nu de method DoSomething toe aan de class definitie:
147159
148-`TExample = class(TObject)`\
149-`public`\
150-`  constructor Create;`\
151-`  procedure DoSomething(i: integer);`\
152-`  destructor Destroy; override;`\
153-`end;`
160+``` pascal
161+TExample = class(TObject)
162+public
163+ constructor Create;
164+ procedure DoSomething(i: integer);
165+ destructor Destroy; override;
166+end;
167+```
154168
155169en druk op Ctrl+Shift+C. De IDE zal het volgende toevoegen
156170
157-`procedure TExample.DoSomething(i: integer);`\
158-`begin`\
159-`  |`\
160-`end;`
171+``` pascal
172+procedure TExample.DoSomething(i: integer);
173+begin
174+ |
175+end;
176+```
161177
162178Afhankelijk 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.
163179
164180**Complete Properties**\
165181Voeg een property toe aan de class:
166182
167-`TExample = class(TObject)`\
168-`public`\
169-`  constructor Create;`\
170-`  procedure DoSomething(i: integer);`\
171-`  destructor Destroy; override;`\
172-`  property AnInteger: Integer;`\
173-`end;`
183+``` pascal
184+TExample = class(TObject)
185+public
186+ constructor Create;
187+ procedure DoSomething(i: integer);
188+ destructor Destroy; override;
189+ property AnInteger: Integer;
190+end;
191+```
174192
175193Druk op Ctrl+Shift+C en het volgende wordt in de implementatie sectie toegevoegd:
176194
177-`procedure TExample.SetAnInteger(const AValue: integer);`\
178-`begin`\
179-`  |if FAnInteger=AValue then exit;`\
180-`  FAnInteger:=AValue;`\
181-`end;`
195+``` pascal
196+procedure TExample.SetAnInteger(const AValue: integer);
197+begin
198+ |if FAnInteger=AValue then exit;
199+ FAnInteger:=AValue;
200+end;
201+```
182202
183203Code 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:
184204
185-`TExample = class(TObject)`\
186-`private`\
187-`  FAnInteger: integer;`\
188-`  procedure SetAnInteger(const AValue: integer);`\
189-`public`\
190-`  constructor Create;`\
191-`  procedure DoSomething(i: integer);`\
192-`  destructor Destroy; override;`\
193-`  property AnInteger: integer read FAnInteger write SetAnInteger;`\
194-`end;`
205+``` pascal
206+TExample = class(TObject)
207+private
208+ FAnInteger: integer;
209+ procedure SetAnInteger(const AValue: integer);
210+public
211+ constructor Create;
212+ procedure DoSomething(i: integer);
213+ destructor Destroy; override;
214+ property AnInteger: integer read FAnInteger write SetAnInteger;
215+end;
216+```
195217
196218Het 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.
197219
198220Je kunt ook een "read only" property maken door:
199221
200-`property PropName: PropType read;`
222+```text
223+property PropName: PropType read;
224+```
201225
202226in te tikken. Als je dan Ctrl+Shift+C drukt wordt dit
203227
204-`property PropName: PropType read FPropName;`
228+```text
229+property PropName: PropType read FPropName;
230+```
205231
206232In theorie kun je een "write only" property maken door:
207233
208-` property PropName: PropType write;`
234+```text
235+ property PropName: PropType write;
236+```
209237
210238in te tikken, wat dan door Code Completion wordt aangevuld tot
211239
212-`property PropName: PropType write SetPropName;`
240+```text
241+property PropName: PropType write SetPropName;
242+```
213243
214244Het 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):
215245
216-`property PropName: PropType read GetPropName;`
246+```text
247+property PropName: PropType read GetPropName;
248+```
217249
218250Deze regel wordt dan niet veranderd, maar code completion zal wel de GetPropName function toevoegen:
219251
220-`function GetpropName: PropType;`
252+``` pascal
253+function GetpropName: PropType;
254+```
221255
222256Je kunt ook een property maken met een "stored" modifier:
223257
224-`property PropName: PropType stored;`
258+```text
259+property PropName: PropType stored;
260+```
225261
226262dit zal worden uitgebreid door CodeCompletion tot:
227263
228-`property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;`
264+```text
265+property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;
266+```
229267
230268De stored modifier bepaald of een property wordt opgeslagen met de form definitie. Als het niet is opgegeven wordt de waarde True aangenomen.
231269
232270Tip: Identifier completion herkent ook incomplete properties en zal de standaard namen voorstellen. Dus bijvoorbeeld::
233271
234-`property PropName: PropType read |;`
272+```text
273+property PropName: PropType read |;
274+```
235275
236276Als 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'.
237277
238278### Forward Procedure Completion
239279
240280"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.
241281
242282Bijvoorbeeld: Voeg een nieuwe procedure toe aan de interface sectie:
243283
244-`procedure DoSomething;`
284+``` pascal
285+procedure DoSomething;
286+```
245287
246288Zet de cursor er op en druk Ctrl+Shift+C. Er zal dan in de implementatie sectie een raamwerk voor de procedure worden gemaakt:
247289
248-`procedure DoSomething;`\
249-`begin`\
250-`  |`\
251-`end;`
290+``` pascal
291+procedure DoSomething;
292+begin
293+ |
294+end;
295+```
252296
253297Tip: Ook hier kun je tussen de definitie en de implementatie heen en weer springen met Ctrl+Shift+Up.
254298
255299Waar 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:
256300
257-` procedure Proc1;`\
258-` procedure Proc2; // Nieuw`\
259-` procedure Proc3;`
301+``` pascal
302+ procedure Proc1;
303+ procedure Proc2; // Nieuw
304+ procedure Proc3;
305+```
260306
261307Als de implementaties van Proc1 en Proc3 al aanwezig zijn, zal de implementatie van Proc2 hier tussen geplaatst worden.
262308
263309Meerdere procedures in een keer kan ook:
264310
265-`procedure Proc1_Old; // Bestaat al, implementatie aanwezig.`\
266-`procedure Proc2_New; // Implementatie niet aanwezig.`\
267-`procedure Proc3_New; //  "`\
268-`procedure Proc4_New; //  "`\
269-`procedure Proc5_Old; // Bestaat al, implementatie aanwezig.`
311+``` pascal
312+procedure Proc1_Old; // Bestaat al, implementatie aanwezig.
313+procedure Proc2_New; // Implementatie niet aanwezig.
314+procedure Proc3_New; // "
315+procedure Proc4_New; // "
316+procedure Proc5_Old; // Bestaat al, implementatie aanwezig.
317+```
270318
271319In dit geval zullen er door Code Completion 3 procedure implementaties worden toegevoegd (Proc2_New, Proc3_New, Proc4_New).
272320
273321Waarom heet dit nu "Forward Procedure Completion"? Eigenlijk heel simpel, omdat het ook werkt bij procedures die met de "forward" modifier zijn gedefinieerd!
274322
275323### Event Assignment Completion
276324
277325"Event Assignment Completion" is ook een onderdeel van de Code Completion en completeerd een
278326
279-`Event := |`
327+``` pascal
328+Event := |
329+```
280330
281331statement. Druk je nu op Ctrl+Shift+C zoals in het volgende voorbeeld:
282332
283-`procedure TForm1.Form1Create(Sender: TObject);`\
284-`begin`\
285-`  OnPaint:=|`\
286-`end;`
333+``` pascal
334+procedure TForm1.Form1Create(Sender: TObject);
335+begin
336+ OnPaint:=|
337+end;
338+```
287339
288340De '\|' is natuurlijk weer de plaats van de cursor! Als je nu op press Ctrl+Shift+C drukt het statement zal worden gecompleteerd tot:
289341
290-`OnPaint:=@Form1Paint;`
342+``` pascal
343+OnPaint:=@Form1Paint;
344+```
291345
292346In de definitie van TForm1 zal deze methode worden opgenomen en in de implementatie sectie zal het skelet van de procedure gezet worden:
293347
294-`procedure TForm1.Form1Paint(Sender: TObject);`\
295-`begin`\
296-`  |`\
297-`end;`
348+``` pascal
349+procedure TForm1.Form1Paint(Sender: TObject);
350+begin
351+ |
352+end;
353+```
298354
299355Eigenlijk precies zo als bij het toevoegen van een methode in de Object Inspector.
300356
301357Let op:\
302358De cursor moet achter de ':=' staan, omdat anders "Local Variable Completion" zal worden aangeroepen. Dit zal echter mislukken want OnPaint is immers al gedefinieerd.
303359
304360Tip:\
305361Je kunt zelf de naam van de method bepalen door bijvoorbeeld:
306362
307-` OnPaint:=@ThePaintMethod;`
363+``` pascal
364+ OnPaint:=@ThePaintMethod;
365+```
308366
309367te typen en daarna Ctrl+Shift+C te geven.
310368
311369### Local Variable Completion
312370
313371"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.
314372
315373Bijvoorbeeld:
316374
317-`procedure TForm1.Form1Create(Sender: TObject);`\
318-`begin`\
319-`  i:=3;`\
320-`end;`
375+``` pascal
376+procedure TForm1.Form1Create(Sender: TObject);
377+begin
378+ i:=3;
379+end;
380+```
321381
322382Plaats de cursor op de 'i' of er net achter, druk dan op Ctrl+Shift+C en dit is het resultaat:
323383
324-`procedure TForm1.Form1Create(Sender: TObject);`\
325-`var`\
326-`  i: Integer;`\
327-`begin`\
328-`  i:=3;`\
329-`end;`
384+``` pascal
385+procedure TForm1.Form1Create(Sender: TObject);
386+var
387+ i: Integer;
388+begin
389+ i:=3;
390+end;
391+```
330392
331393Code 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.
332394
333395Een ander voorbeeld, die wat meer de ingebouwde intelligentie aantoont: type
334396
335-` TWhere = (Behind, Middle, InFront);`\
397+``` pascal
398+ TWhere = (Behind, Middle, InFront);
336399
337-` procedure TForm1.Form1Create(Sender: TObject);`\
338-` var`\
339-`   a: array[TWhere] of char;`\
340-` begin`\
341-`   for Where:=Low(a) to High(a) do writeln(a[Where]);`\
342-` end;`
400+ procedure TForm1.Form1Create(Sender: TObject);
401+ var
402+ a: array[TWhere] of char;
403+ begin
404+ for Where:=Low(a) to High(a) do writeln(a[Where]);
405+ end;
406+```
343407
344408Plaats de cursor op 'Where' en druk op Ctrl+Shift+C. Je krijgt dan:
345409
346-`procedure TForm1.Form1Create(Sender: TObject);`\
347-`var`\
348-`  a: array[TWhere] of char;`\
349-`  Where: TWhere;`\
350-`begin`\
351-`  for Where:=Low(a) to High(a) do writeln(a[Where]);`\
352-`end;`
410+``` pascal
411+procedure TForm1.Form1Create(Sender: TObject);
412+var
413+ a: array[TWhere] of char;
414+ Where: TWhere;
415+begin
416+ for Where:=Low(a) to High(a) do writeln(a[Where]);
417+end;
418+```
353419
354420### Commentaar en Code Completion
355421
356422Code Completion zal het commentaar zoveel mogelijk daar houden waar het hoort. Bij voorbeeld:
357423
358-` FList: TList; // lijst van TComponent`\
359-` FInt: integer;`
424+```text
425+ FList: TList; // lijst van TComponent
426+ FInt: integer;
427+```
360428
361429Als er een nieuwe variabele tussen wordt gezet, zal het commentaar op de regel van FList blijven. Het zelfde geldt voor
362430
363-` FList: TList; { lijst van TComponent`\
364-`   Dit is commentaar over meerdere regels, dat begint`\
365-`   op de FList regel, so Code Completion neemt aan dat `\
366-`   het bij FList hoort en zal deze deze relatie niet`\
367-`   verbreken. Nieuwe code wordt hierna geplaatst. }`\
368-` FInt: integer;`
431+```text
432+ FList: TList; { lijst van TComponent
433+ Dit is commentaar over meerdere regels, dat begint
434+ op de FList regel, so Code Completion neemt aan dat
435+ het bij FList hoort en zal deze deze relatie niet
436+ verbreken. Nieuwe code wordt hierna geplaatst. }
437+ FInt: integer;
438+```
369439
370440Maar in het volgende voorbeeld:
371441
372-` FList: TList; // list of TComponent`\
373-`   { Dit commentaar behoort tot het volgende statement.`\
374-`     Nieuwe code kan dus hierboven worden toegevoegd en`\
375-`     na het commentaar van de FList regel. }`\
376-` FInt: integer;`
442+```text
443+ FList: TList; // list of TComponent
444+ { Dit commentaar behoort tot het volgende statement.
445+ Nieuwe code kan dus hierboven worden toegevoegd en
446+ na het commentaar van de FList regel. }
447+ FInt: integer;
448+```
377449
378450## Refactoring
379451
380452### Invert Assignments
381453
382454Samenvatting
383455
384456"Invert Assignments" draait geselecteerde pascal statements om. Je kunt het gebruiken voor het omvormen van "bewaar" code naar "inlees" code.
385457
386458Een voorbeeld zal een en ander wat duidelijker maken:\
387-procedure DoSomething;
388459
389-`begin`\
390-`  AValueStudio:= BValueStudio;`\
391-`  AValueAppartment :=BValueAppartment;`\
392-`  AValueHouse:=BValueHouse;`\
393-`end;`
460+``` pascal
461+procedure DoSomething;
462+begin
463+ AValueStudio:= BValueStudio;
464+ AValueAppartment :=BValueAppartment;
465+ AValueHouse:=BValueHouse;
466+end;
467+```
394468
395469Selecteer 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:
396470
397-`procedure DoSomething;`\
398-`begin`\
399-`  BValueStudio     := AValueStudio;`\
400-`  BValueAppartment := AValueAppartment;`\
401-`  BValueHouse      := AValueHouse;`\
402-`end;`
471+``` pascal
472+procedure DoSomething;
473+begin
474+ BValueStudio := AValueStudio;
475+ BValueAppartment := AValueAppartment;
476+ BValueHouse := AValueHouse;
477+end;
478+```
403479
404480### Extract Procedure
405481
406482Samenvatting
407483
408484"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.
409485
410486*De basis:*\
411-procedure DoSomething;
412487
413-`begin`\
414-`  Statement1;`\
415-`  Statement2;`\
416-`  Statement3;`\
417-`end;`
488+``` pascal
489+procedure DoSomething;
490+begin
491+ Statement1;
492+ Statement2;
493+ Statement3;
494+end;
495+```
418496
419497Selecteer 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:
420498
421-`procedure NewProc;`\
422-`begin`\
423-`  Statement1;`\
424-`  Statement2;`\
425-`  Statement3;`\
426-`end;`\
499+``` pascal
500+procedure NewProc;
501+begin
502+ Statement1;
503+ Statement2;
504+ Statement3;
505+end;
427506
428-`procedure DoSomething;`\
429-`begin`\
430-`  NewProc;`\
431-`end;`
507+procedure DoSomething;
508+begin
509+ NewProc;
510+end;
511+```
432512
433513Zoals 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.
434514
435515*Lokale Variabelen en Parameters:*\
436516"Extract Procedure" zal automatisch de code scannen voor lokale variabele en deze aanmaken. Ook eventuele parameters worden automatisch aangemaakt. Bijvoorbeeld:
437517
438-`procedure TForm1.DoSomething(var Ernie, Bert: integer);`\
439-`var`\
440-`  I: Integer; // Commentaar`\
441-`begin`\
442-`  Ernie:=Ernie+Bert;`\
443-`  for I:=Ernie to 5 do begin`\
444-`  |`\
445-`  end;`\
446-`end;`
518+``` pascal
519+procedure TForm1.DoSomething(var Ernie, Bert: integer);
520+var
521+ I: Integer; // Commentaar
522+begin
523+ Ernie:=Ernie+Bert;
524+ for I:=Ernie to 5 do begin
525+ |
526+ end;
527+end;
528+```
447529
448530Selecteer 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.
449531
450532Het resultaat:\
451-procedure NewProc(const Erni: integer);
452533
453-`var`\
454-`  i: Integer; // Commentaar`\
455-`begin`\
456-`  for i:=Ernie to 5 do begin`\
457-`  |`\
458-`  end;`\
459-`end;`\
534+``` pascal
535+procedure NewProc(const Erni: integer);
536+var
537+ i: Integer; // Commentaar
538+begin
539+ for i:=Ernie to 5 do begin
540+ |
541+ end;
542+end;
460543
461-`procedure TForm1.DoSomething(var Erni, Bert: integer);`\
462-`begin`\
463-`  Ernie:=Ernie+Bert;`\
464-`  NewProc(Ernie);`\
465-`end;`
544+procedure TForm1.DoSomething(var Erni, Bert: integer);
545+begin
546+ Ernie:=Ernie+Bert;
547+ NewProc(Ernie);
548+end;
549+```
466550
467551Zoals je ziet is de I in zijn geheel verplaatst naar de nieuwe procedure inclusief het bijbehorende commentaar.
468552
469553Beperkingen:\
470554Omdat pascal een hoop mogelijkheden heeft, moet je niet verwachten dat het altijd even goed werkt. Huidige beperkingen en "ToDo"s:
471555
472556- Controle op het overeenkomen van selectie grenzen met statement grenzen
473557- betere bepaling van het type van de parameters. Op het moment zijn parameters "const", als het "var" moeten zijn, moet je dat zelf wijzigen.
474558- "with" statements
475559
476560## Find Declaration
477561
478562Find 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.
479563
480564Iedere 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).
481565
482566De codetools houden rekening met de "normale" pascal regels. Hoewel de compiler alleen het laatste resultaat geeft, zien de codetools alle tussenliggende stappen. Bijvoorbeeld:
483567
484568De '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.
485569
486570Iets soort gelijks geldt bijvoorbeeld voor TColor. Uiteindelijk is TColor niets anders dan een 'longint'. Maar in de sources is het als volgt gedefinieerd:
487571
488-`TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;`\
489-`TColor = TGraphicsColor;`
572+```text
573+TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;
574+TColor = TGraphicsColor;
575+```
490576
491577Een voorbeeld van een 'forward' gedefinieerd control. In TControl is een private variabele gedefinieerd:
492578
493-`FHostDockSite: TWinControl;`
579+```text
580+FHostDockSite: TWinControl;
581+```
494582
495583Gebruik je in TControl Find declaration voor TWinControl, dan zal er naar de forward definitie gesprongen worden.
496584
497-`TWinControl = class;`
585+```text
586+TWinControl = class;
587+```
498588
499589Gebruik je hier dan nog eens de Find Declaratie, pas dan zal er naar de werkelijke definitie gesprongen worden:
500590
501-`TWinControl = class(TControl)`
591+```text
592+TWinControl = class(TControl)
593+```
502594
503595Het mag duidelijk zijn dat je op deze manier iedere identifier kunt opsporen en iedere overload terugvinden.
504596
505597## Goto Include Directive
506598
507599"Goto Include Directive" te vinden in het search menu van de IDE springt naar het {\$I filename} statement waar het huidige bestand wordt gebruikt.
508600
509601## Publish Project
510602
511603Maakt 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.
512604
513605In 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.
514606
515607In 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.
516608
517609---
518610*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