Lazarus IDE Tools/fr: what changed

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

Old	New		Line
1	1		## Vue d'ensemble
2	2
3	3		L'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).
4	4
5	5		Parce 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é.
6	6
7	7		## Tableau synoptique des raccourcis de l'EDI
8	8
9	9		\| \| \|
10	10		\|----\|----\|
11	11		\| [[Lazarus IDE Tools/fr\|Saut de Déclaration]] \| Ctrl+Clic (saut à la déclaration du type ou de la variable) \|
12	12		\| [[Lazarus IDE Tools/fr\|Saut de Méthode]] \| Ctrl+Maj+Haut (basculer entre la définition et le corps) \|
13	13		\| [[Lazarus IDE Tools/fr\|Code Templates]] \| Ctrl+J \|
14	14		\| [[Lazarus IDE Tools/fr\|Complétion de code]] (Complétion de classe) \| Ctrl+Maj+C \|
15	15		\| [[Lazarus IDE Tools/fr\|Complétion d'identificateur]] \| Ctrl+Espace \|
16	16		\| [[Lazarus IDE Tools/fr\|Complétion de Mot]] \| Ctrl+W \|
17	17		\| [[Lazarus IDE Tools/fr\|Conseils de paramètre]] \| Ctrl+Shift+Space \|
18	18
19	19		## Saut de Méthode
20	20
21	21		Pour sauter du corps d'une procédure (begin..end) à sa définition (procédure NomProcedure;) utilisez Ctrl+Maj+Haut.
22	22
23	23		Par exemple :
24	24
25	25		`interface`\
26		-	\
	26	+
27	27		`procedure DoSomething; // déclaration de la procédure`\
28	28		` `\
29	29		`implementation`\
30	30		` `\
31	31		`procedure DoSomething; // corps de la procédure `\
32	32		`begin`\
33	33		`end;`
34	34
35	35		Si 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'.
36	36
37	37		Ceci fonctionne également avec les méthodes (procédures dans les classes).
38	38
39	39		Conseils : '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).
40	40
41	41		Par exemple une procédure avec différents types de paramètre :
42	42
43	43		`interface`\
44		-	\
	44	+
45	45		`procedure DoSomething(p: char); // déclaration de la procédure`\
46		-	\
	46	+
47	47		`implementation`\
48	48		` `\
49	49		`procedure DoSomething(p: string); // corps de la procédure`\
50	50		`begin`\
51	51		`end;`
52	52
53	53		Sauter 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.
54	54
55	55		Par exemple :\
56	56		Vous avez renommé 'DoSomething' en 'MakeIt' :
57	57
58	58		`interface`\
59		-	\
	59	+
60	60		`procedure MakeIt; // déclaration de la procédure`\
61		-	\
	61	+
62	62		`implementation`\
63		-	\
	63	+
64	64		`procedure DoSomething; // corps de la procédure`\
65	65		`begin`\
66	66		`end;`
67	67
68	68		Lorsque 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.
69	69
70	70		## Fichiers d'inclusion
71	71
72	72		Les 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.
73	73
74	74		Contrairement à 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.
75	75
76	76		Par 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.
77	77
78	78		Mais 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.
79	79
80	80		Dè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.
81	81
82	82		Ce mécanisme a naturellement des limites. Certains fichiers d'inclusion sont inclus deux fois ou plus. Par exemple : lcl/include/winapih.inc.
83	83
84	84		Sauter 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. ;)
85	85
86	86		## Code Templates
87	87
88	88		Les Code Templates convertissent un identificateur en texte ou en fragment de code.
89	89
90	90		Le 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.
91	91
92	92		Exemple : écrivez 'classf ', laissez le curseur juste derrière le 'f ' et appuyez Ctrl+J. Le 'classf 'sera remplacé par
93	93
94	94		`T = class(T)`\
95	95		`private`\
96		-	\
	96	+
97	97		`public`\
98	98		` constructor Create;`\
99	99		` destructor Destroy; override;`\
100	100		`end;`
101	101
102	102		et 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.
103	103
104	104		Les plus grands économiseurs de temps sont les templates 'b'+Ctrl+J pour begin..end.
105	105
106	106		## Conseils de paramètre
107	107
108	108		Les conseils de paramètre montrent une boîte de conseil avec les déclarations de paramètres pour la liste courante de paramètres .
109	109
110	110		Par exemple
111	111
112	112		`Canvas.FillRect(\|);`
113	113
114	114		Placer 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.
115	115
116	116		## Complétion de code
117	117
118	118		Pour 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".
119	119
120	120		La complétion de code combine de puissantes fonctions. Exemples :
121	121
122	122		- [[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 ;
123	123		- [[Lazarus IDE Tools/fr\|Complétion de procédure vers l'avant]] : ajoute des corps de procédure ;
124	124		- [[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 ;
125	125		- [[Lazarus IDE Tools/fr\|Complétion de déclaration de variable]] : ajoute des définitions de variables locales.
126	126
127	127		La fonction utilisée dépend de la position du curseur dans l'éditeur.
128	128
129	129		Le 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.
130	130
131	131		### Complétion de classe
132	132
133	133		Le 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.
134	134
135	135		Par exemple : créez une classe (voir les code templates pour savoir quel type) :
136	136
137	137		`TExample = class(TObject)`\
138	138		`public`\
139	139		` constructor Create;`\
140	140		` destructor Destroy; override;`\
141	141		`end;`
142	142
143	143		Placez 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 :
144	144
145	145		`{ TExample }`\
146		-	\
	146	+
147	147		`constructor TExample.Create;`\
148	148		`begin`\
149	149		` \|`\
150	150		`end;`\
151		-	\
	151	+
152	152		`destructor TExample.Destroy;`\
153	153		`begin`\
154	154		` inherited Destroy;`\
155	155		`end;`
156	156
157	157		Note : '\\|' est le curseur et n'est pas à ajouter.
158	158
159	159		Conseil : vous pouvez sauter entre une méthode et son corps avec Ctrl+Maj+Haut.
160	160
161	161		Vous 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.
162	162
163	163		Ajoutez maintenant une méthode DoSomething :
164	164
165	165		`TExample = class(TObject)`\
166	166		`public`\
167	167		` constructor Create;`\
168	168		` procedure DoSomething(i: integer);`\
169	169		` destructor Destroy; override;`\
170	170		`end;`
171	171
172	172		Ensuite pressez Ctrl+Maj+C et l'EDI ajoutera
173	173
174	174		`procedure TExample.DoSomething(i: integer);`\
175	175		`begin`\
176	176		` \|`\
177	177		`end;`
178	178
179	179		Vous 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.
180	180
181	181		Compléter les Propriétés\
182	182		Ajoutez une propriété AnInteger :
183	183
184	184		`TExample = class(TObject)`\
185	185		`public`\
186	186		` constructor Create;`\
187	187		` procedure DoSomething(i: integer);`\
188	188		` destructor Destroy; override;`\
189	189		` property AnInteger: Integer;`\
190	190		`end;`
191	191
192	192		Appuyez Ctrl+Maj+C et vous obtiendrez :
193	193
194	194		`procedure TExample.SetAnInteger(const AValue: integer);`\
195	195		`begin`\
196	196		` \|if FAnInteger=AValue then exit;`\
197	197		` FAnInteger:=AValue;`\
198	198		`end;`
199	199
200	200		La 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 :
201	201
202	202		`TExample = class(TObject)`\
203	203		`private`\
204	204		` FAnInteger: integer;`\
205	205		` procedure SetAnInteger(const AValue: integer);`\
206	206		`public`\
207	207		` constructor Create;`\
208	208		` procedure DoSomething(i: integer);`\
209	209		` destructor Destroy; override;`\
210	210		` property AnInteger: integer read FAnInteger write SetAnInteger;`\
211	211		`end;`
212	212
213	213		La 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.
214	214
215	215		Une propriété créée pour la lecture seule :
216	216
217	217		`property PropName: PropType read;`
218	218
219	219		sera étendue en
220	220
221	221		`property PropName: PropType read FPropName;`
222	222
223	223		Une propriété créée en écriture seule
224	224
225	225		` property PropName: PropType write;`
226	226
227	227		sera étendue en
228	228
229	229		`property PropName: PropType write SetPropName;`
230	230
231	231		Une propriété créée en lecture seule avec une méthode read
232	232
233	233		`property PropName: PropType read GetPropName;`
234	234
235	235		sera conservée et la fonction GetPropName sera ajoutée
236	236
237	237		`function GetpropName: PropType;`
238	238
239	239		Créer une propriété avec un spécificateur de stockage
240	240
241	241		`property PropName: PropType stored;`
242	242
243	243		sera étendue en
244	244
245	245		`property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;`
246	246
247	247		Puisque le stockage est utilisé pour les spécificateurs de flux de lecture/écriture le code est complété en fonction.
248	248
249	249		Conseil : la complétion d'identificateur reconnaît aussi des propriétés incomplètes et suggérera les noms implicites. Par exemple :
250	250
251	251		`property PropName: PropType read \|;`
252	252
253	253		Placez 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 '.
254	254
255	255		### Complétion de procédure vers l'avant
256	256
257	257		La "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.
258	258
259	259		Par exemple : Ajoutez une nouvelle procédure dans la section interface :
260	260
261	261		`procedure DoSomething;`
262	262
263	263		Placez le curseur dessus et appuyez Ctrl+Maj+C pour compléter le code. Elle sera crée dans la section implémentation :
264	264
265	265		`procedure DoSomething;`\
266	266		`begin`\
267	267		` \|`\
268	268		`end;`
269	269
270	270		Conseil : vous pouvez sauter entre une définition de procédure et son corps avec Ctrl+Maj+Haut.
271	271
272	272		Le 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 :
273	273
274	274		` procedure Proc1;`\
275	275		` procedure Proc2; // nouvelle procédure`\
276	276		` procedure Proc3;`
277	277
278	278		Si 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.
279	279
280	280		Procédures multiples :
281	281
282	282		`procedure Proc1_Old; // le corps existe`\
283	283		`procedure Proc2_New; // le corps n'existe pas`\
284	284		`procedure Proc3_New; // "`\
285	285		`procedure Proc4_New; // "`\
286	286		`procedure Proc5_Old; // le corps existe`
287	287
288	288		La complétion de code ajoutera chacun des 3 corps de procédure (Proc2_New, Proc3_New, Proc4_New).
289	289
290	290		Pourquoi l'appeler "Complétion de procédure vers l'avant" ?
291	291
292	292		Parce 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".
293	293
294	294		### Complétion d'assignation d'événement
295	295
296	296		"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.
297	297
298	298		Par exemple : dans une méthode, par exemple l'événement FormCreate, ajoutez une ligne 'OnPaint : = ':
299	299
300	300		`procedure TForm1.Form1Create(Sender: TObject);`\
301	301		`begin`\
302	302		` OnPaint:=\|`\
303	303		`end;`
304	304
305	305		Le '\\|' est le curseur et ne doit pas être ajouté. Appuyez sur Ctrl+Maj+C pour compléter le code. Le rapport sera rempli par
306	306
307	307		`OnPaint:=@Form1Paint;`
308	308
309	309		Une nouvelle méthode Form1Paint sera ajoutée à la classe TForm1. Alors la complétion de classe est lancée et vous obtiendrez :
310	310
311	311		`procedure TForm1.Form1Paint(Sender: TObject);`\
312	312		`begin`\
313	313		` \|`\
314	314		`end;`
315	315
316	316		Ceci fonctionne seulement pour ajouter des méthodes dans l'inspecteur d'objet.
317	317
318	318		Note:\
319	319		vous 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.
320	320
321	321		Conseil :\
322	322		vous pouvez définir le nouveau nom de méthode par vous-même. Par exemple :
323	323
324	324		` OnPaint:=@ThePaintMethod;`
325	325
326	326		### Complétion de déclaration de variable
327	327
328	328		La "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.
329	329
330	330		Par exemple :
331	331
332	332		`procedure TForm1.Form1Create(Sender: TObject);`\
333	333		`begin`\
334	334		` i:=3;`\
335	335		`end;`
336	336
337	337		Placez 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 :
338	338
339	339		`procedure TForm1.Form1Create(Sender: TObject);`\
340	340		`var`\
341	341		` i: Integer;`\
342	342		`begin`\
343	343		` i:=3;`\
344	344		`end;`
345	345
346	346		Les 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 ': = '.
347	347
348	348		Un autre exemple :
349	349
350	350		`type`\
351	351		` TWhere = (Behind, Middle, InFront);`\
352		-	\
	352	+
353	353		` procedure TForm1.Form1Create(Sender: TObject);`\
354	354		` var`\
355	355		` a: array[TWhere] of char;`\
356	356		` begin`\
357	357		` for Where:=Low(a) to High(a) do writeln(a[Where]);`\
358	358		` end;`
359	359
360	360		Placez le curseur sur 'Where' et appuyez sur Ctrl+Maj+C pour la complétion de code. Vous obtenez :
361	361
362	362		` procedure TForm1.Form1Create(Sender: TObject);`\
363	363		` var`\
364	364		` a: array[TWhere] of char;`\
365	365		` Where: TWhere;`\
366	366		` begin`\
367	367		` for Where:=Low(a) to High(a) do writeln(a[Where]);`\
368	368		` end;`
369	369
370	370		Depuis la version 0.9.11 Lazarus complète également des paramètres. Par exemple
371	371
372	372		` procedure TForm1.FormPaint(Sender: TObject);`\
373	373		` begin`\
374	374		` with Canvas do begin`\
375	375		` Line(x1,y1,x2,y2);`\
376	376		` end;`\
377	377		` end;`
378	378
379	379		Placez le curseur sur 'x1 'et appuyez sur Ctrl+Maj+C pour la complétion de code. Vous obtenez :
380	380
381	381		` procedure TForm1.FormPaint(Sender: TObject);`\
382	382		` var`\
383	383		` x1: integer;`\
384	384		` begin`\
385	385		` with Canvas do begin`\
386	386		` Line(x1,y1,x2,y2);`\
387	387		` end;`\
388	388		` end;`
389	389
390	390		### Complétion inverse de classe
391	391
392	392		La "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.
393	393
394	394		Par exemple :
395	395
396	396		` procedure TForm1.DoSomething(Sender: TObject);`\
397	397		` begin`\
398	398		` end;`
399	399
400	400		La 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.
401	401
402	402		Pour 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.
403	403
404	404		### Commentaires et Complétion de code
405	405
406	406		La complétion de code essaie de conserver les commentaires là où ils sont. Par exemple :
407	407
408	408		` FList: TList; // liste de TComponent`\
409	409		` FInt: integer;`
410	410
411	411		En insérant une nouvelle variable entre FList et FInt, le commentaire est maintenu dans la ligne de FList. C'est également vrai pour
412	412
413	413		` FList: TList; { list of TComponent`\
414	414		` This is a comment over several lines, starting`\
415	415		` in the FList line, so codetools assumes it belongs `\
416	416		` to the FLIst line and will not break this `\
417	417		` relationship. Code is inserted behind the comment. }`\
418	418		` FInt: integer;`
419	419
420	420		Si le commentaire commence à la ligne suivante :
421	421
422	422		` FList: TList; // liste de TComponent`\
423	423		` { This comment belongs to the statement below. `\
424	424		` New code is inserted above this comment and `\
425	425		` behind the comment of the FList line. }`\
426	426		` FInt: integer;`
427	427
428	428		## Réusinage de code (Refactoring)
429	429
430	430		### Inverser les assignations
431	431
432	432		Résumé
433	433		"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.
434	434
435	435		Exemple :\
436	436		procedure DoSomething;
437	437
438	438		`begin`\
439	439		` AValueStudio:= BValueStudio;`\
440	440		` AValueAppartment :=BValueAppartment;`\
441	441		` AValueHouse:=BValueHouse;`\
442	442		`end;`
443	443
444	444		Choisissez 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 :
445	445
446	446		Résultat :
447	447
448	448		`procedure DoSomething;`\
449	449		`begin`\
450	450		` BValueStudio := AValueStudio;`\
451	451		` BValueAppartment := AValueAppartment;`\
452	452		` BValueHouse := AValueHouse;`\
453	453		`end;`
454	454
455	455		### Procédure d'extraction
456	456
457	457		Résumé
458	458		L'"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.
459	459
460	460		Exemple basique :\
461	461		procedure DoSomething;
462	462
463	463		`begin`\
464	464		` CallSomething;`\
465	465		`end;`
466	466
467	467		Choisissez 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 :
468	468
469	469		`procedure NewProc;`\
470	470		`begin`\
471	471		` CallSomething;`\
472	472		`end;`\
473		-	\
	473	+
474	474		`procedure DoSomething;`\
475	475		`begin`\
476	476		` NewProc;`\
477	477		`end;`
478	478
479	479		Vous 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".
480	480
481	481		Variables locales et paramètres :\
482	482		l'"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 :
483	483
484	484		`procedure TForm1.DoSomething(var Erni, Bert: integer);`\
485	485		`var`\
486	486		` i: Integer; // Commentaire`\
487	487		`begin`\
488	488		` Erni:=Erni+Bert;`\
489	489		` for i:=Erni to 5 do begin`\
490	490		` \|`\
491	491		` end;`\
492	492		`end;`
493	493
494	494		Sé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.
495	495
496	496		Résultat :\
497	497		procedure NewProc(const Erni: integer);
498	498
499	499		`var`\
500	500		` i: Integer; // Commentaire`\
501	501		`begin`\
502	502		` for i:=Erni to 5 do begin`\
503	503		` \|`\
504	504		` end;`\
505	505		`end;`\
506		-	\
	506	+
507	507		`procedure TForm1.DoSomething(var Erni, Bert: integer);`\
508	508		`begin`\
509	509		` Erni:=Erni+Bert;`\
510	510		` NewProc(Erni);`\
511	511		`end;`
512	512
513	513		Vous pouvez voir que "i" a été déplacée dans la nouvelle procédure (avec son commentaire), de même que Erni.
514	514
515	515		Limitations :\
516	516		le Pascal est un langage très puissant, ainsi cela fonctionnera sur chaque code. Les limites actuelles sont :
517	517
518	518		- qu'il vous faut vérifier que les limites de la sélection soient compatibles avec la portée des variables ;
519	519		- la déclaration "with".
520	520
521	521		## Trouver la référence de l'identificateur
522	522
523	523		Placez 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.
524	524
525	525		Il 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 :
526	526
527	527		la 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.
528	528
529	529		C'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
530	530
531	531		`TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;`\
532	532		`TColor = TGraphicsColor;`
533	533
534	534		Il en va de même pour les classes précédentes : Par exemple dans TControl, il y a une variable privée
535	535
536	536		`FHostDockSite: TWinControl;`
537	537
538	538		Trouver la déclaration de TWinControl saute à la définition précédente
539	539
540	540		`TWinControl = class;`
541	541
542	542		En l'appelant encore on atteint l'implémentation réelle
543	543
544	544		`TWinControl = class(TControl)`
545	545
546	546		De cette façon, vous pouvez dépister chaque identificateur et trouver chaque surcharge.
547	547
548	548		## complétion d'identificateur
549	549
550	550		La "complétion d'identificateur" est appelée par Ctrl+Space. Elle montre tous les identificateurs à portée. Par exemple :
551	551
552	552		` procedure TForm1.FormCreate(Sender: TObject);`\
553	553		` begin`\
554	554		` \|`\
555	555		` end;`
556	556
557	557		Placer 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 .
558	558
559	559		Note au utilisateurs de Delphi : Delphi l'appelle complétion de Code.
560	560
561	561		Quelques 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 .
562	562
563	563		La 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.
564	564
565	565		La complétion d'identificateur montre même ces identificateurs, qui ne sont pas compatibles.
566	566
567	567		### Préfixe
568	568
569	569		Vous pouvez commencer la complétion d'identificateur en un mot. Alors les lettres vers la gauche seront prises comme préfixe. Par exemple :
570	570
571	571		` procedure TForm1.FormCreate(Sender: TObject);`\
572	572		` begin`\
573	573		` Ca\|ption`\
574	574		` end;`
575	575
576	576		La boîte vous montrera seulement les identificateurs commençant par 'Ca'.
577	577
578	578		### Touches
579	579
580	580		- Lettre ou nombre : ajouter le caractère à l'éditeur de source et le préfixe courant. Ceci mettra à jour la liste ;
581	581		- Backspace: enlève le dernier caractère de l'éditeur de source et le préfixe. Met à jour la liste ;
582	582		- Entrée: remplace le mot entier au curseur avec l'identificateur choisi et ferme la fenêtre popup ;
583	583		- Shift+Entrée: comme Entrée, mais remplace seulement le préfixe (partie gauche) du mot au curseur ;
584	584		- Haut/Bas: déplace la sélection ;
585	585		- Echap: Ferme le popup sans changement ;
586	586		- 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' ;
587	587		- Else: comme Entrée et ajoute le caractère à l'éditeur de source ;
588	588
589	589		## Complétion de mot
590	590
591	591		La "complétion de mot" est appelée par Ctrl+W. Elle montre tous les mots de tous les éditeurs actuellement ouverts.
592	592
593	593		Sinon, elle travaille de la même manière que la complétion d'identificateur.
594	594
595	595		## Aller à la directive include
596	596
597	597		"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é.
598	598
599	599		## Publier le Projet
600	600
601	601		Cré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.
602	602
603	603		Le 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".
604	604
605	605		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.
606	606
607	607		Dans 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.
608	608
609	609		## Contributeurs originaux
610	610
611	611		Cette page a été convertie de la version d'epikwiki [version](http://lazarus-ccr.sourceforge.net/index.php?wiki=LazarusIdeTools).
612	612
613	613		- Page créée et modèle initial – 06/04/2004 VlxAdmin
614	614		- Contenu initial posté – 10/04/2004 MattiasG
615	615		- Petit wiki et correction du formatage – 11/04/2004 VlxAdmin
616	616		- Ajout d'un tableau synoptique pour des raccourcis des outils de l'EDI 12 juillet 2004 User:Kirkpatc
617	617
618	618		---
619	619		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