Sign in Join
Wiki copytemporary

Lazarus IDE Tools/fr: what changed

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

OldNewLine
11## Vue d'ensemble
22
33L'EDI Lazarus utilise des outils d'analyse et d'édition, appelés les "outils de code". Ces outils permettent de retrouver une déclaration, de compléter du code, d'extraire, de déplacer, d'insérer, et de mettre en valeur des sources pascal. Ces fonctions font gagner du temps et permettent de doubler le rendement. Elles sont paramétrables et chacune d'entre elles est accessible par l'intermédiaire de raccourcis (cf. les options de l'éditeur).
44
55Parce qu'ils travaillent uniquement sur des sources et du code FPC (FPC : Free Pascal Compiler), Delphi, et Kylix compréhensible, ils n'ont pas besoin d'unités compilées ni d'un compilateur Borland installé. Vous pouvez éditer le code Delphi et celui du FPC en même temps. Vous pouvez même travailler avec plusieurs versions de Delphi et FPC en même temps. Ce qui rend le portage du code source Delphi beaucoup plus aisé.
66
77## Tableau synoptique des raccourcis de l'EDI
88
99| | |
1010|----|----|
1111| [[Lazarus IDE Tools/fr|Saut de Déclaration]] | Ctrl+Clic (saut à la déclaration du type ou de la variable) |
1212| [[Lazarus IDE Tools/fr|Saut de Méthode]] | Ctrl+Maj+Haut (basculer entre la définition et le corps) |
1313| [[Lazarus IDE Tools/fr|Code Templates]] | Ctrl+J |
1414| [[Lazarus IDE Tools/fr|Complétion de code]] (Complétion de classe)   | Ctrl+Maj+C |
1515| [[Lazarus IDE Tools/fr|Complétion d'identificateur]] | Ctrl+Espace |
1616| [[Lazarus IDE Tools/fr|Complétion de Mot]] | Ctrl+W |
1717| [[Lazarus IDE Tools/fr|Conseils de paramètre]] | Ctrl+Shift+Space |
1818
1919## Saut de Méthode
2020
2121Pour sauter du corps d'une procédure (begin..end) à sa définition (procédure NomProcedure;) utilisez Ctrl+Maj+Haut.
2222
2323Par exemple :
2424
25-`interface`\
25+``` pascal
26+interface
2627
27-`procedure DoSomething; // déclaration de la procédure`\
28-` `\
29-`implementation`\
30-` `\
31-`procedure DoSomething; // corps de la procédure `\
32-`begin`\
33-`end;`
28+procedure DoSomething; // déclaration de la procédure
29+
30+implementation
31+
32+procedure DoSomething; // corps de la procédure
33+begin
34+end;
35+```
3436
3537Si le curseur est dans le corps de la procédure appuyez sur Ctrl+Maj+Haut, le curseur sautera à la définition. Une nouvelle pression sur les touches Ctrl+Maj+Haut sautera de la déclaration au corps, après 'begin'.
3638
3739Ceci fonctionne également avec les méthodes (procédures dans les classes).
3840
3941Conseils : 'Saut de Méthode' saute jusqu'à la même procédure du même nom et de même(s) paramètre(s). Si aucune procédure ne correspond, le saut se fait sur la plus ressemblante et place le curseur sur la première différence. (Note aux Delphinautes : Delphi ne sait pas le faire).
4042
4143Par exemple une procédure avec différents types de paramètre :
4244
43-`interface`\
45+``` pascal
46+interface
4447
45-`procedure DoSomething(p: char); // déclaration de la procédure`\
48+procedure DoSomething(p: char); // déclaration de la procédure
4649
47-`implementation`\
48-`  `\
49-`procedure DoSomething(p: string); // corps de la procédure`\
50-`begin`\
51-`end;`
50+implementation
51+
52+procedure DoSomething(p: string); // corps de la procédure
53+begin
54+end;
55+```
5256
5357Sauter de la définition au corps placera le curseur sur le mot-clé 'string'. Ceci peut être employé pour renommer des méthodes et/ou changer les paramètres.
5458
5559Par exemple :\
5660Vous avez renommé 'DoSomething' en 'MakeIt' :
5761
58-`interface`\
62+``` pascal
63+interface
5964
60-`procedure MakeIt; // déclaration de la procédure`\
65+procedure MakeIt; // déclaration de la procédure
6166
62-`implementation`\
67+implementation
6368
64-`procedure DoSomething; // corps de la procédure`\
65-`begin`\
66-`end;`
69+procedure DoSomething; // corps de la procédure
70+begin
71+end;
72+```
6773
6874Lorsque vous sautez de MakeIt au corps. L'EDI recherche le corps correspondant, ne le trouve pas, et par conséquent recherche le meilleur 'candidat'. Puisque vous n'avez renommé qu'une procédure il n'y a qu'un corps de procédure sans définition (DoSomething) et ainsi le saut se fera sur DoSomething et le curseur se placera sur 'DoSomething'. Maintenant, il suffit simplement de la renommer ici aussi. Ceci fonctionne de la même manière sur des paramètres.
6975
7076## Fichiers d'inclusion
7177
7278Les fichiers d'inclusion sont des fichiers insérés dans les sources à l'aide de la directive de compilation {\$I nom de fichier} ou {\$INCLUDE nom de fichier}. Lazarus et FPC l'utilisent beaucoup pour éviter la redondance de l'illisible {\$IFDEF} conçue pour supporter différentes plateformes.
7379
7480Contrairement à Delphi, l'EDI Lazarus intègre le support complet des fichiers d'inclusion. Vous pouvez par exemple sauter de la méthode du fichier .pas au corps de la méthode dans le fichier d'inclusion. Tous les outils de code comme la complétion de code, considèrent les fichiers d'inclusion en tant que marqueurs spéciaux.
7581
7682Par exemple : quand la complétion de code ajoute un nouveau corps de méthode derrière un autre corps de méthode, il les maintient tous les deux dans le même fichier. De cette façon, vous pouvez mettre l'implémentation de la classe, entièrement dans le fichier d'inclusion, comme le LCL le fait pour presque tous les composants.
7783
7884Mais il y a un piège pour le novice : si vous ouvrez un fichier d'inclusion pour la première fois, et que vous essayez de sauter à la méthode, ou de trouver sa déclaration, vous obtiendrez un message d'erreur. L'EDI ne sait pas à quelle unité le fichier d'inclusion fait référence. Vous devez ouvrir l'unité d'abord.
7985
8086Dès que l'EDI analysera l'unité, il analysera les directives d'inclusion et se rappellera cette relation. Il sauvegardera cette information sur la sortie et sur le projet sauvegardé sous ~/.lazarus/includelinks.xml. La prochaine fois que vous ouvrirez le fichier d'inclusion et ferez un saut ou une recherche de déclaration, l'EDI retrouvera l'unité et le saut fonctionnera.
8187
8288Ce mécanisme a naturellement des limites. Certains fichiers d'inclusion sont inclus deux fois ou plus. Par exemple : lcl/include/winapih.inc.
8389
8490Sauter des définitions de procedure/method dans le fichier d'inclusion aux corps dépend de vos dernières actions. Si vous travailliez sur lcl/lclintf.pp l'EDI sautera sur winapi.inc. Si vous travailliez à lcl/interfacebase.pp, alors il sautera à lcl/include/interfacebase.inc (ou à l'un des autres fichiers d'inclusion). Si vous travaillez sur les deux, alors vous pouvez vous emmêler les pinceaux. ;)
8591
8692## Code Templates
8793
8894Les Code Templates convertissent un identificateur en texte ou en fragment de code.
8995
9096Le raccourci par défaut des Code Templates est Ctrl+J. Vous pouvez saisir un identificateur, presser Ctrl+J et l'identificateur est remplacé par le texte défini pour cet identificateur. Des Code Templates peuvent être définis dans l'environnement - \> Configuration - \> Code Templates.
9197
9298Exemple : écrivez 'classf ', laissez le curseur juste derrière le 'f ' et appuyez Ctrl+J. Le 'classf 'sera remplacé par
9399
94-`T = class(T)`\
95-`private`\
100+``` pascal
101+T = class(T)
102+private
96103
97-`public`\
98-`  constructor Create;`\
99-`  destructor Destroy; override;`\
100-`end;`
104+public
105+ constructor Create;
106+ destructor Destroy; override;
107+end;
108+```
101109
102110et le curseur sera derrière le 'T'. Vous pouvez obtenir la liste des identificateurs en plaçant le curseur sur un espace (pas sur un identificateur) et en appuyant sur Ctrl+J. La liste des code templates apparaîtra. Utilisez la souris, les touches de direction du clavier ou saisissez quelques caractères pour en choisir un. La touche entrée crée le modèle sélectionné et quitte la fenêtre pop up.
103111
104112Les plus grands économiseurs de temps sont les templates 'b'+Ctrl+J pour begin..end.
105113
106114## Conseils de paramètre
107115
108116Les conseils de paramètre montrent une boîte de conseil avec les déclarations de paramètres pour la liste courante de paramètres .
109117
110118Par exemple
111119
112-`Canvas.FillRect(|);`
120+```text
121+Canvas.FillRect(|);
122+```
113123
114124Placer le curseur dans les parenthèses et presser sur Ctrl+Shift+Space. Une boîte de conseil apparaîtra montrant les paramètres de FillRect.
115125
116126## Complétion de code
117127
118128Pour les Delphinautes : Delphi appelle la "Complétion de code" la fonction montrant la liste des identificateurs à la position courante du code source (Ctrl+Espace). Sous Lazarus cela s'appelle le "Complétion d'identificateur".
119129
120130La complétion de code combine de puissantes fonctions. Exemples :
121131
122132- [[Lazarus IDE Tools/fr|Complétion de classe]] : complète des propriétés, ajoute des corps de méthode, ajoute des variables et des méthodes privées ;
123133- [[Lazarus IDE Tools/fr|Complétion de procédure vers l'avant]] : ajoute des corps de procédure ;
124134- [[Lazarus IDE Tools/fr|Complétion d'assignation d'événement]] : complète les assignations d'événement et ajoute la définition et le corps de la méthode ;
125135- [[Lazarus IDE Tools/fr|Complétion de déclaration de variable]] : ajoute des définitions de variables locales.
126136
127137La fonction utilisée dépend de la position du curseur dans l'éditeur.
128138
129139Le Complétion de code peut être trouvée dans le menu de l'EDI Editer - \> Compléter le code en utilisant le raccourci standard Ctrl+Maj+C.
130140
131141### Complétion de classe
132142
133143Le dispositif de complétion de code le plus puissant est "complétion de classe". Vous écrivez une classe, ajoutez les méthodes et les propriétés et la complétion de code ajoutera les corps de méthode, l'accès méthodes/variables des propriétés et les variables privées.
134144
135145Par exemple : créez une classe (voir les code templates pour savoir quel type) :
136146
137-`TExample = class(TObject)`\
138-`public`\
139-`  constructor Create;`\
140-`  destructor Destroy; override;`\
141-`end;`
147+``` pascal
148+TExample = class(TObject)
149+public
150+ constructor Create;
151+ destructor Destroy; override;
152+end;
153+```
142154
143155Placez le curseur quelque part dans la classe et appuyez Ctrl+Maj+C. Ceci créera les corps de méthode manquants et déplacera le curseur au premier corps de méthode créé, ainsi vous pouvez juste commencer à écrire la classe :
144156
145-`{ TExample }`\
157+``` pascal
158+{ TExample }
146159
147-`constructor TExample.Create;`\
148-`begin`\
149-`  |`\
150-`end;`\
160+constructor TExample.Create;
161+begin
162+ |
163+end;
151164
152-`destructor TExample.Destroy;`\
153-`begin`\
154-`  inherited Destroy;`\
155-`end;`
165+destructor TExample.Destroy;
166+begin
167+ inherited Destroy;
168+end;
169+```
156170
157171Note : '\|' est le curseur et n'est pas à ajouter.
158172
159173Conseil : vous pouvez sauter entre une méthode et son corps avec Ctrl+Maj+Haut.
160174
161175Vous pouvez voir que l'EDI a ajouté 'inherited Destroy'. Ceci est fait s'il y a le mot clé 'override' dans la définition de classe.
162176
163177Ajoutez maintenant une méthode DoSomething :
164178
165-`TExample = class(TObject)`\
166-`public`\
167-`  constructor Create;`\
168-`  procedure DoSomething(i: integer);`\
169-`  destructor Destroy; override;`\
170-`end;`
179+``` pascal
180+TExample = class(TObject)
181+public
182+ constructor Create;
183+ procedure DoSomething(i: integer);
184+ destructor Destroy; override;
185+end;
186+```
171187
172188Ensuite pressez Ctrl+Maj+C et l'EDI ajoutera
173189
174-`procedure TExample.DoSomething(i: integer);`\
175-`begin`\
176-`  |`\
177-`end;`
190+``` pascal
191+procedure TExample.DoSomething(i: integer);
192+begin
193+ |
194+end;
195+```
178196
179197Vous constaterez, que le nouveau corps de méthode a été inséré entre Create et Destroy, exactement comme dans la définition de classe. De cette façon, le corps du programme garde la même logique que celle que vous avez définie dans la classe. Vous pouvez définir la politique d'insertion dans l'environnement -\> Configuration -\> Modèles de code.
180198
181199**Compléter les Propriétés**\
182200Ajoutez une propriété AnInteger :
183201
184-`TExample = class(TObject)`\
185-`public`\
186-`  constructor Create;`\
187-`  procedure DoSomething(i: integer);`\
188-`  destructor Destroy; override;`\
189-`  property AnInteger: Integer;`\
190-`end;`
202+``` pascal
203+TExample = class(TObject)
204+public
205+ constructor Create;
206+ procedure DoSomething(i: integer);
207+ destructor Destroy; override;
208+ property AnInteger: Integer;
209+end;
210+```
191211
192212Appuyez Ctrl+Maj+C et vous obtiendrez :
193213
194-`procedure TExample.SetAnInteger(const AValue: integer);`\
195-`begin`\
196-`  |if FAnInteger=AValue then exit;`\
197-`  FAnInteger:=AValue;`\
198-`end;`
214+``` pascal
215+procedure TExample.SetAnInteger(const AValue: integer);
216+begin
217+ |if FAnInteger=AValue then exit;
218+ FAnInteger:=AValue;
219+end;
220+```
199221
200222La complétion de code a ajouté un spécificateur d'accès en écriture ainsi que du code courant. Sautez à la classe avec Ctrl+Maj+Haut pour voir les changements :
201223
202-`TExample = class(TObject)`\
203-`private`\
204-`  FAnInteger: integer;`\
205-`  procedure SetAnInteger(const AValue: integer);`\
206-`public`\
207-`  constructor Create;`\
208-`  procedure DoSomething(i: integer);`\
209-`  destructor Destroy; override;`\
210-`  property AnInteger: integer read FAnInteger write SetAnInteger;`\
211-`end;`
224+``` pascal
225+TExample = class(TObject)
226+private
227+ FAnInteger: integer;
228+ procedure SetAnInteger(const AValue: integer);
229+public
230+ constructor Create;
231+ procedure DoSomething(i: integer);
232+ destructor Destroy; override;
233+ property AnInteger: integer read FAnInteger write SetAnInteger;
234+end;
235+```
212236
213237La propriété a été étendue avec des spécificateurs d'accès en lecture et en écriture. La classe a intégré une nouvelle section 'privée' avec une variable 'FAnInteger' et la méthode 'SetAnInteger '. C'est une convention de Delphi que d'ajouter des variables privées avec un 'F 'et la méthode d'inscription avec un 'Set'. Si vous n'aimez pas, vous pouvez la modifier dans l'environnement -\> Configuration -\> Options... -\> Outils de code -\> Class completion.
214238
215239Une propriété créée pour la lecture seule :
216240
217-`property PropName: PropType read;`
241+```text
242+property PropName: PropType read;
243+```
218244
219245sera étendue en
220246
221-`property PropName: PropType read FPropName;`
247+```text
248+property PropName: PropType read FPropName;
249+```
222250
223251Une propriété créée en écriture seule
224252
225-` property PropName: PropType write;`
253+```text
254+ property PropName: PropType write;
255+```
226256
227257sera étendue en
228258
229-`property PropName: PropType write SetPropName;`
259+```text
260+property PropName: PropType write SetPropName;
261+```
230262
231263Une propriété créée en lecture seule avec une méthode read
232264
233-`property PropName: PropType read GetPropName;`
265+```text
266+property PropName: PropType read GetPropName;
267+```
234268
235269sera conservée et la fonction GetPropName sera ajoutée
236270
237-`function GetpropName: PropType;`
271+``` pascal
272+function GetpropName: PropType;
273+```
238274
239275Créer une propriété avec un spécificateur de stockage
240276
241-`property PropName: PropType stored;`
277+```text
278+property PropName: PropType stored;
279+```
242280
243281sera étendue en
244282
245-`property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;`
283+```text
284+property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;
285+```
246286
247287Puisque le stockage est utilisé pour les spécificateurs de flux de lecture/écriture le code est complété en fonction.
248288
249289Conseil : la complétion d'identificateur reconnaît aussi des propriétés incomplètes et suggérera les noms implicites. Par exemple :
250290
251-`property PropName: PropType read |;`
291+```text
292+property PropName: PropType read |;
293+```
252294
253295Placez l'espace du curseur derrière le mot-clé 'read' et appuyez sur Ctrl+Espace pour la complétion d'identificateur. Il vous présentera la variable 'FPropName' et la procédure 'SetPropName '.
254296
255297### Complétion de procédure vers l'avant
256298
257299La "Complétion de procédure vers l'avant" fait partie de la complétion de code et ajoute les corps des procédures absentes. Elle est appelée quand le curseur est sur une procédure déjà définie.
258300
259301Par exemple : Ajoutez une nouvelle procédure dans la section interface :
260302
261-`procedure DoSomething;`
303+``` pascal
304+procedure DoSomething;
305+```
262306
263307Placez le curseur dessus et appuyez Ctrl+Maj+C pour compléter le code. Elle sera crée dans la section implémentation :
264308
265-`procedure DoSomething;`\
266-`begin`\
267-`  |`\
268-`end;`
309+``` pascal
310+procedure DoSomething;
311+begin
312+ |
313+end;
314+```
269315
270316Conseil : vous pouvez sauter entre une définition de procédure et son corps avec Ctrl+Maj+Haut.
271317
272318Le nouveau corps de procédure sera ajouté devant les méthodes de classe. S'il y a déjà quelques procédures dans l'interface, l'EDI essaye de garder l'ordre. Par exemple :
273319
274-` procedure Proc1;`\
275-` procedure Proc2; // nouvelle procédure`\
276-` procedure Proc3;`
320+``` pascal
321+ procedure Proc1;
322+ procedure Proc2; // nouvelle procédure
323+ procedure Proc3;
324+```
277325
278326Si les corps de Proc1 et de Proc3 existent déjà, alors le corps Proc2 sera inséré entre les corps de Proc1 et Proc3. Ce comportement peut être paramétré dans l'environnement -\> Configuration -\> Options... -\> Outils de code -\> Création de code -\> Préserver l'ordre des procédures.
279327
280328Procédures multiples :
281329
282-`procedure Proc1_Old; // le corps existe`\
283-`procedure Proc2_New; // le corps n'existe pas`\
284-`procedure Proc3_New; //  "`\
285-`procedure Proc4_New; //  "`\
286-`procedure Proc5_Old; // le corps existe`
330+``` pascal
331+procedure Proc1_Old; // le corps existe
332+procedure Proc2_New; // le corps n'existe pas
333+procedure Proc3_New; // "
334+procedure Proc4_New; // "
335+procedure Proc5_Old; // le corps existe
336+```
287337
288338La complétion de code ajoutera chacun des 3 corps de procédure (Proc2_New, Proc3_New, Proc4_New).
289339
290340Pourquoi l'appeler "Complétion de procédure vers l'avant" ?
291341
292342Parce qu'elle fonctionne non seulement pour les procédures définies dans l'interface, mais aussi pour les procédures avec le spécificateur "Forward".
293343
294344### Complétion d'assignation d'événement
295345
296346"La complétion d'assignation d'événement" fait partie de la complétion de code Event : = NomMethode. Elle est appelée quand le curseur est derrière l'assignation d'un événement.
297347
298348Par exemple : dans une méthode, par exemple l'événement FormCreate, ajoutez une ligne 'OnPaint : = ':
299349
300-`procedure TForm1.Form1Create(Sender: TObject);`\
301-`begin`\
302-`  OnPaint:=|`\
303-`end;`
350+``` pascal
351+procedure TForm1.Form1Create(Sender: TObject);
352+begin
353+ OnPaint:=|
354+end;
355+```
304356
305357Le '\|' est le curseur et ne doit pas être ajouté. Appuyez sur Ctrl+Maj+C pour compléter le code. Le rapport sera rempli par
306358
307-`OnPaint:=@Form1Paint;`
359+``` pascal
360+OnPaint:=@Form1Paint;
361+```
308362
309363Une nouvelle méthode Form1Paint sera ajoutée à la classe TForm1. Alors la complétion de classe est lancée et vous obtiendrez :
310364
311-`procedure TForm1.Form1Paint(Sender: TObject);`\
312-`begin`\
313-`  |`\
314-`end;`
365+``` pascal
366+procedure TForm1.Form1Paint(Sender: TObject);
367+begin
368+ |
369+end;
370+```
315371
316372Ceci fonctionne seulement pour ajouter des méthodes dans l'inspecteur d'objet.
317373
318374Note:\
319375vous devez placer le curseur derrière l'opérateur ': = '. Si vous placez le curseur sur l'identificateur (par exemple OnPaint), la complétion de code appellera "la complétion de variable locale", qui échouera, car onPaint est déjà définie.
320376
321377Conseil :\
322378vous pouvez définir le nouveau nom de méthode par vous-même. Par exemple :
323379
324-` OnPaint:=@ThePaintMethod;`
380+``` pascal
381+ OnPaint:=@ThePaintMethod;
382+```
325383
326384### Complétion de déclaration de variable
327385
328386La "complétion de déclaration de variable" fait partie de la complétion de code et ajoute une définition de variable locale pour un Identificateur:=ValeureAAffecter. Elle est appelée quand le curseur est sur l'identificateur d'une tâche ou d'un paramètre.
329387
330388Par exemple :
331389
332-`procedure TForm1.Form1Create(Sender: TObject);`\
333-`begin`\
334-`  i:=3;`\
335-`end;`
390+``` pascal
391+procedure TForm1.Form1Create(Sender: TObject);
392+begin
393+ i:=3;
394+end;
395+```
336396
337397Placez le curseur sur le 'i' ou juste derrière lui. Appuyez alors sur Ctrl+Maj+C pour la complétion de code et vous obtiendrez :
338398
339-`procedure TForm1.Form1Create(Sender: TObject);`\
340-`var`\
341-`  i: Integer;`\
342-`begin`\
343-`  i:=3;`\
344-`end;`
399+``` pascal
400+procedure TForm1.Form1Create(Sender: TObject);
401+var
402+ i: Integer;
403+begin
404+ i:=3;
405+end;
406+```
345407
346408Les outils de code font les premières vérifications, si la variable 'i' n'est pas encore déclarée, la déclaration est intégrée au code. Le type de la variable est automatiquement détecté en fonction du type de la valeur affectée à la variable à droite de l'opérateur ': = '.
347409
348410Un autre exemple :
349411
350-`type`\
351-` TWhere = (Behind, Middle, InFront);`\
412+``` pascal
413+type
414+ TWhere = (Behind, Middle, InFront);
352415
353-` procedure TForm1.Form1Create(Sender: TObject);`\
354-` var`\
355-`   a: array[TWhere] of char;`\
356-` begin`\
357-`   for Where:=Low(a) to High(a) do writeln(a[Where]);`\
358-` end;`
416+ procedure TForm1.Form1Create(Sender: TObject);
417+ var
418+ a: array[TWhere] of char;
419+ begin
420+ for Where:=Low(a) to High(a) do writeln(a[Where]);
421+ end;
422+```
359423
360424Placez le curseur sur 'Where' et appuyez sur Ctrl+Maj+C pour la complétion de code. Vous obtenez :
361425
362-` procedure TForm1.Form1Create(Sender: TObject);`\
363-` var`\
364-`   a: array[TWhere] of char;`\
365-`   Where: TWhere;`\
366-` begin`\
367-`   for Where:=Low(a) to High(a) do writeln(a[Where]);`\
368-` end;`
426+``` pascal
427+ procedure TForm1.Form1Create(Sender: TObject);
428+ var
429+ a: array[TWhere] of char;
430+ Where: TWhere;
431+ begin
432+ for Where:=Low(a) to High(a) do writeln(a[Where]);
433+ end;
434+```
369435
370436Depuis la version 0.9.11 Lazarus complète également des paramètres. Par exemple
371437
372-` procedure TForm1.FormPaint(Sender: TObject);`\
373-` begin`\
374-`   with Canvas do begin`\
375-`     Line(x1,y1,x2,y2);`\
376-`   end;`\
377-` end;`
438+``` pascal
439+ procedure TForm1.FormPaint(Sender: TObject);
440+ begin
441+ with Canvas do begin
442+ Line(x1,y1,x2,y2);
443+ end;
444+ end;
445+```
378446
379447Placez le curseur sur 'x1 'et appuyez sur Ctrl+Maj+C pour la complétion de code. Vous obtenez :
380448
381-` procedure TForm1.FormPaint(Sender: TObject);`\
382-` var`\
383-`   x1: integer;`\
384-` begin`\
385-`   with Canvas do begin`\
386-`     Line(x1,y1,x2,y2);`\
387-`   end;`\
388-` end;`
449+``` pascal
450+ procedure TForm1.FormPaint(Sender: TObject);
451+ var
452+ x1: integer;
453+ begin
454+ with Canvas do begin
455+ Line(x1,y1,x2,y2);
456+ end;
457+ end;
458+```
389459
390460### Complétion inverse de classe
391461
392462La "Complétion inverse de classe" est un aspect la complétion de code. Elle ajoute une déclaration de méthode privée correspondant au corps de méthode courant. Elle est appelée quand le curseur se trouve dans le corps d'une méthode qui n'est pas encore définie dans la classe. Cette fonctionnalité est disponible depuis la version 0.9.21 de Lazarus.
393463
394464Par exemple :
395465
396-` procedure TForm1.DoSomething(Sender: TObject);`\
397-` begin`\
398-` end;`
466+``` pascal
467+ procedure TForm1.DoSomething(Sender: TObject);
468+ begin
469+ end;
470+```
399471
400472La méthode DoSomething n'est pas encore déclarée dans TForm1. Pressez Ctrl+Shift+C et l'IDE ajoutera "procedure DoSomething(Sender: TObject);" aux méthodes privées de TForm1.
401473
402474Pour les delphinautes : la complétion de code sous Lazarus fonctionne toujours dans un seul sens : de l'interface de la classe à son implémentation, ou à l'envers de l'implémentation de la classe à son interface. Delphi fonctionne toujours dans les deux sens, ce qui a pour inconvénient qu'une coquille engendrera facilement - sans avertissement - une nouvelle amorce de méthode.
403475
404476### Commentaires et Complétion de code
405477
406478La complétion de code essaie de conserver les commentaires là où ils sont. Par exemple :
407479
408-` FList: TList; // liste de TComponent`\
409-` FInt: integer;`
480+```text
481+ FList: TList; // liste de TComponent
482+ FInt: integer;
483+```
410484
411485En insérant une nouvelle variable entre FList et FInt, le commentaire est maintenu dans la ligne de FList. C'est également vrai pour
412486
413-` FList: TList; { list of TComponent`\
414-`   This is a comment over several lines, starting`\
415-`   in the FList line, so codetools assumes it belongs `\
416-`   to the FLIst line and will not break this `\
417-`   relationship. Code is inserted behind the comment. }`\
418-` FInt: integer;`
487+```text
488+ FList: TList; { list of TComponent
489+ This is a comment over several lines, starting
490+ in the FList line, so codetools assumes it belongs
491+ to the FLIst line and will not break this
492+ relationship. Code is inserted behind the comment. }
493+ FInt: integer;
494+```
419495
420496Si le commentaire commence à la ligne suivante :
421497
422-` FList: TList; // liste de TComponent`\
423-`   { This comment belongs to the statement below. `\
424-`     New code is inserted above this comment and `\
425-`     behind the comment of the FList line. }`\
426-` FInt: integer;`
498+```text
499+ FList: TList; // liste de TComponent
500+ { This comment belongs to the statement below.
501+ New code is inserted above this comment and
502+ behind the comment of the FList line. }
503+ FInt: integer;
504+```
427505
428506## Réusinage de code (Refactoring)
429507
430508### Inverser les assignations
431509
432510Résumé
433511"L'inversion d'assignation" inverse toutes les affectation du code sélectionné de l'éditeur. Cet outil est très pratique pour transformer un code de "sauvegarde" en code de "chargement", l'une étant l'opération inverse de l'autre.
434512
435513Exemple :\
436-procedure DoSomething;
437514
438-`begin`\
439-`  AValueStudio:= BValueStudio;`\
440-`  AValueAppartment :=BValueAppartment;`\
441-`  AValueHouse:=BValueHouse;`\
442-`end;`
515+``` pascal
516+procedure DoSomething;
517+begin
518+ AValueStudio:= BValueStudio;
519+ AValueAppartment :=BValueAppartment;
520+ AValueHouse:=BValueHouse;
521+end;
522+```
443523
444524Choisissez les lignes avec affectation (entre begin et end) et inversez les affectations. Toutes les affectations seront inversées et l'indentation sera ajoutée automatiquement. Par exemple :
445525
446526Résultat :
447527
448-`procedure DoSomething;`\
449-`begin`\
450-`  BValueStudio     := AValueStudio;`\
451-`  BValueAppartment := AValueAppartment;`\
452-`  BValueHouse      := AValueHouse;`\
453-`end;`
528+``` pascal
529+procedure DoSomething;
530+begin
531+ BValueStudio := AValueStudio;
532+ BValueAppartment := AValueAppartment;
533+ BValueHouse := AValueHouse;
534+end;
535+```
454536
455537### Procédure d'extraction
456538
457539Résumé
458540L'"extraction de procédure" récupère le code pascal sélectionné est crée une procédure/méthode avec ce code. Cet outil est utile pour dédoubler de grandes procédures ou pour créer facilement une nouvelle procédure à partir d'un certain code.
459541
460542Exemple basique :\
461-procedure DoSomething;
462543
463-`begin`\
464-`  CallSomething;`\
465-`end;`
544+``` pascal
545+procedure DoSomething;
546+begin
547+ CallSomething;
548+end;
549+```
466550
467551Choisissez la ligne "CallSomething;" et extrayez Proc. Une boîte de dialogue apparaît et vous pouvez choisir le type et le nom de la procédure à créer. Par exemple : procédure, "NewProc". Résultat :
468552
469-`procedure NewProc;`\
470-`begin`\
471-`  CallSomething;`\
472-`end;`\
553+``` pascal
554+procedure NewProc;
555+begin
556+ CallSomething;
557+end;
473558
474-`procedure DoSomething;`\
475-`begin`\
476-`  NewProc;`\
477-`end;`
559+procedure DoSomething;
560+begin
561+ NewProc;
562+end;
563+```
478564
479565Vous constaterez que la nouvelle procédure "NewProc" a été créée avec la sélection tandis que le vieux code a été remplacé par un appel à "NewProc".
480566
481567Variables locales et paramètres :\
482568l'"Extraction de procédure" récupère les variables utilisées et crée automatiquement la liste des paramètres et les variables locales. Exemple :
483569
484-`procedure TForm1.DoSomething(var Erni, Bert: integer);`\
485-`var`\
486-`  i: Integer; // Commentaire`\
487-`begin`\
488-`  Erni:=Erni+Bert;`\
489-`  for i:=Erni to 5 do begin`\
490-`  |`\
491-`  end;`\
492-`end;`
570+``` pascal
571+procedure TForm1.DoSomething(var Erni, Bert: integer);
572+var
573+ i: Integer; // Commentaire
574+begin
575+ Erni:=Erni+Bert;
576+ for i:=Erni to 5 do begin
577+ |
578+ end;
579+end;
580+```
493581
494582Sélectionnez la boucle for et créez une nouvelle procédure "NewProc". La variable locale i n'est utilisée que dans la sélection, ainsi elle sera déplacée dans la nouvelle procédure. Erni est également employée dans le code restant, dans lequel elle deviendra un paramètre.
495583
496584Résultat :\
497-procedure NewProc(const Erni: integer);
498585
499-`var`\
500-`  i: Integer; // Commentaire`\
501-`begin`\
502-`  for i:=Erni to 5 do begin`\
503-`  |`\
504-`  end;`\
505-`end;`\
586+``` pascal
587+procedure NewProc(const Erni: integer);
588+var
589+ i: Integer; // Commentaire
590+begin
591+ for i:=Erni to 5 do begin
592+ |
593+ end;
594+end;
506595
507-`procedure TForm1.DoSomething(var Erni, Bert: integer);`\
508-`begin`\
509-`  Erni:=Erni+Bert;`\
510-`  NewProc(Erni);`\
511-`end;`
596+procedure TForm1.DoSomething(var Erni, Bert: integer);
597+begin
598+ Erni:=Erni+Bert;
599+ NewProc(Erni);
600+end;
601+```
512602
513603Vous pouvez voir que "i" a été déplacée dans la nouvelle procédure (avec son commentaire), de même que Erni.
514604
515605Limitations :\
516606le Pascal est un langage très puissant, ainsi cela fonctionnera sur chaque code. Les limites actuelles sont :
517607
518608- qu'il vous faut vérifier que les limites de la sélection soient compatibles avec la portée des variables ;
519609- la déclaration "with".
520610
521611## Trouver la référence de l'identificateur
522612
523613Placez le curseur sur un identificateur et "trouver la référence de l'identificateur". Alors elle recherchera la déclaration de cet identificateur, ouvrira le fichier et se positionnera dessus. Chaque déclaration a un point de saut. Cela signifie que le saut peut se faire dans un sens ou dans l'autre avec Chercher -\> En arrière.
524614
525615Il y a quelques différences avec Delphi : les outils de code travaillent sur des sources selon les règles normales du Pascal, au lieu d'employer le compilateur. Le compilateur renvoie le type final. Les outils de code voient les sources et toutes les étapes intermédiaires. Par exemple :
526616
527617la propriété "Visible" est d'abord définie dans TControl (controls.pp), ensuite, elle est redéfinie dans TCustomForm et finalement redéfinie dans TForm. Vous pouvez appeler "trouver la référence de l'identificateur" sur "Visible" pour le retrouver dans TForm. Par conséquent, vous pouvez appeler de nouveau "trouver la référence de l'identificateur" pour sauter à "Visible" dans TCustomForm, et une fois encore pour sauter à "Visible" dans TControl.
528618
529619C'est également vrai pour des types comme Tcolor. Pour le compilateur c'est simplement un "longint". Mais dans les sources, il est défini comme
530620
531-`TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;`\
532-`TColor = TGraphicsColor;`
621+```text
622+TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;
623+TColor = TGraphicsColor;
624+```
533625
534626Il en va de même pour les classes précédentes : Par exemple dans TControl, il y a une variable privée
535627
536-`FHostDockSite: TWinControl;`
628+```text
629+FHostDockSite: TWinControl;
630+```
537631
538632Trouver la déclaration de TWinControl saute à la définition précédente
539633
540-`TWinControl = class;`
634+```text
635+TWinControl = class;
636+```
541637
542638En l'appelant encore on atteint l'implémentation réelle
543639
544-`TWinControl = class(TControl)`
640+```text
641+TWinControl = class(TControl)
642+```
545643
546644De cette façon, vous pouvez dépister chaque identificateur et trouver chaque surcharge.
547645
548646## complétion d'identificateur
549647
550648La "complétion d'identificateur" est appelée par Ctrl+Space. Elle montre tous les identificateurs à portée. Par exemple :
551649
552-` procedure TForm1.FormCreate(Sender: TObject);`\
553-` begin`\
554-`   |`\
555-` end;`
650+``` pascal
651+ procedure TForm1.FormCreate(Sender: TObject);
652+ begin
653+ |
654+ end;
655+```
556656
557657Placer le curseur entre *begin* et *end* et appuyez sur Ctrl+Space. L'IDE/Outil de code va maintenant analyser tout code accessible et vous présenter une liste de tous les identificateurs trouvés. L'outil de code met en cache les résultats, ainsi l'appeler une deuxième fois sera beaucoup plus rapide .
558658
559659**Note au utilisateurs de Delphi :** Delphi l'appelle *complétion de Code*.
560660
561661Quelques identificateurs comme 'Write', 'ReadLn', 'Low', 'SetLength', 'Self', 'Result', 'Copy' sont construits dans le compilateur et ne sont pas définis n'importe où dans la source. La complétion d'identificateur a aussi beaucoup de ces choses incorporées. Si vous en trouvez une qui manque, créer juste une demande de fonctionnalité dans le traqueur de bogue .
562662
563663La complétion d'identificateur ne complète pas **les mots clef**. Ainsi vous ne pouvez pas l'employer pour compléter 'proc' en 'procedure'. Pour ces choses utilisez Ctrl+W complétion de mot au lieu de Ctrl+J Code Templates.
564664
565665La complétion d'identificateur montre même ces identificateurs, qui ne sont pas compatibles.
566666
567667### Préfixe
568668
569669Vous pouvez commencer la complétion d'identificateur en un mot. Alors les lettres vers la gauche seront prises comme préfixe. Par exemple :
570670
571-` procedure TForm1.FormCreate(Sender: TObject);`\
572-` begin`\
573-`   Ca|ption`\
574-` end;`
671+``` pascal
672+ procedure TForm1.FormCreate(Sender: TObject);
673+ begin
674+ Ca|ption
675+ end;
676+```
575677
576678La boîte vous montrera seulement les identificateurs commençant par 'Ca'.
577679
578680### Touches
579681
580682- Lettre ou nombre : ajouter le caractère à l'éditeur de source et le préfixe courant. Ceci mettra à jour la liste ;
581683- Backspace: enlève le dernier caractère de l'éditeur de source et le préfixe. Met à jour la liste ;
582684- Entrée: remplace le mot entier au curseur avec l'identificateur choisi et ferme la fenêtre popup ;
583685- Shift+Entrée: comme *Entrée*, mais remplace seulement le préfixe (partie gauche) du mot au curseur ;
584686- Haut/Bas: déplace la sélection ;
585687- Echap: Ferme le popup sans changement ;
586688- Tab: complète le préfixe au choix suivant. Par exemple, le préfixe courant est 'But' et la complétion d'identificateur montre seulement 'Button1' et 'Button1Click'. Alors appuyer sur *Tab* complétera le préfixe avec 'Button1' ;
587689- Else: comme *Entrée* et ajoute le caractère à l'éditeur de source ;
588690
589691## Complétion de mot
590692
591693La "complétion de mot" est appelée par Ctrl+W. Elle montre tous les mots de tous les éditeurs actuellement ouverts.
592694
593695Sinon, elle travaille de la même manière que la complétion d'identificateur.
594696
595697## Aller à la directive include
596698
597699"Aller à la directive 'Include'" dans le menu "Chercher" de l'EDI saute à {\$I nom de fichier} où le fichier d'inclusion en cours est utilisé.
598700
599701## Publier le Projet
600702
601703Crée une copie complète du projet. Si vous voulez envoyer à quelqu'un juste les sources de votre programme et les paramètres du compilateur, cette fonction est faite pour vous.
602704
603705Le dossier (répertoire) d'un projet normal contient beaucoup d'information. La majeure partie n'est pas nécessaire à l'édition : le fichier .lpi contient les informations de session (comme la position du curseur, les favoris (bookmarks) et les unités fermées) et le fichier du projet contient beaucoup de fichiers .ppu, .o et l'exécutable. Créer un fichier .lpi avec seulement l'information de base et seulement les sources, avec tout ses sous-dossiers en utilisant "Publier le projet".
604706
605707**Note**: depuis la version 0.9.13, il y a une nouvelle "option de projet" qui permet de stocker l'information de session dans un dossier séparé du fichier .lpi. Ce nouveau fichier a l'extension .lps et contient seulement les informations de session, ce qui laisse le fichier .lpi beaucoup plus propre.
606708
607709Dans la boîte de dialogue vous pouvez mettre en place un filtre d'inclusion et d'exclusion, et avec la commande suivante vous pouvez compresser le résultat dans une archive.
608710
609711## Contributeurs originaux
610712
611713Cette page a été convertie de la version d'epikwiki [version](http://lazarus-ccr.sourceforge.net/index.php?wiki=LazarusIdeTools).
612714
613715- Page créée et modèle initial – 06/04/2004 VlxAdmin
614716- Contenu initial posté – 10/04/2004 MattiasG
615717- Petit wiki et correction du formatage – 11/04/2004 VlxAdmin
616718- Ajout d'un tableau synoptique pour des raccourcis des outils de l'EDI 12 juillet 2004 User:Kirkpatc
617719
618720---
619721*From the Free Pascal wiki, page "Lazarus IDE Tools/fr", as it stood on 2014-09-28 after a change by Paulatreides, 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