Difference between revisions of "Lazarus IDE Tools/fr"

From Lazarus wiki
Jump to navigationJump to search
 
(38 intermediate revisions by 4 users not shown)
Line 2: Line 2:
  
 
==Vue d'ensemble==
 
==Vue d'ensemble==
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, l'extraction, le déplacement, l'insertion, et la mise 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).
+
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).
  
Puisqu'ils travaillent uniquement sur des sources et interprète le code du compilateur Free Pascal (FPC : Free Pascal Compiler), le code de Delphi, et Kylix, ils n'ont pas besoin des unités compilées ni qu'un compilateur Borland soit 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é.
+
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é.
  
 
==Tableau synoptique des raccourcis de l'EDI==
 
==Tableau synoptique des raccourcis de l'EDI==
Line 19: Line 19:
 
| [[Lazarus_IDE_Tools/fr#complétion d'identificateur|Complétion d'identificateur]] || Ctrl+Espace
 
| [[Lazarus_IDE_Tools/fr#complétion d'identificateur|Complétion d'identificateur]] || Ctrl+Espace
 
|-
 
|-
| [[Lazarus_IDE_Tools/fr#Complétion de Mots|Complétion de Mot]] || Ctrl+W
+
| [[Lazarus_IDE_Tools/fr#Complétion de mot|Complétion de Mot]] || Ctrl+W
 
|-
 
|-
| [[Lazarus_IDE_Tools/fr#Conseils de paramètre|Parameter Hints]] || Ctrl+Shift+Space
+
| [[Lazarus_IDE_Tools/fr#Conseils de paramètre|Conseils de paramètre]] || Ctrl+Shift+Space
 
|}
 
|}
  
 
==Saut de Méthode==
 
==Saut de Méthode==
Pour sauter du corps d'une procedure (begin..end) et sa définition (procedure NomProcedure;) utilisez Ctrl+Maj+Haut.
+
Pour sauter du corps d'une procédure (begin..end) à sa définition (procédure NomProcedure;) utilisez Ctrl+Maj+Haut.
  
 
Par exemple :
 
Par exemple :
Line 38: Line 38:
 
  end;
 
  end;
  
Si le curseur est dans le corps de la procédure appuyez 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'.
+
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'.
  
 
Ceci fonctionne également avec les méthodes (procédures dans les classes).
 
Ceci fonctionne également avec les méthodes (procédures dans les classes).
  
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 sais pas le faire).
+
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).
  
 
Par exemple une procédure avec différents types de paramètre :
 
Par exemple une procédure avec différents types de paramètre :
Line 72: Line 72:
  
 
==Fichiers d'inclusion==
 
==Fichiers d'inclusion==
Les fichiers d'inclusion sont des fichiers inséré dans les sources à l'aide de la directive de compilation {$I nom de fichier} ou {$INCLUDE nom de fichier}. Lazarus et FPC l'utilise beaucoup pour éviter la redondance de l'illisible {$IFDEF} conçue pour supporter différentes plateformes.
+
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.
  
 
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.
 
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.
 
   
 
   
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 fait pour presque tous les composants.
+
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.
  
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.
+
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.
  
 
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.
 
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.
  
Ce mécanisme a naturellement des limites. Certains fichiers d'inclusion sont inclus deux ou plusieurs fois. Par exemple : lcl/include/winapih.inc.
+
Ce mécanisme a naturellement des limites. Certains fichiers d'inclusion sont inclus deux fois ou plus. Par exemple : lcl/include/winapih.inc.
  
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'inclusions). Si vous travaillez sur les deux, alors vous pouvez vous emmêler les pinceaux. ;)
+
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. ;)
  
 
==Code Templates==
 
==Code Templates==
Les Code Templates convertissent un identifiant en texte ou en fragment de code.
+
Les Code Templates convertissent un identificateur en texte ou en fragment de code.
  
Le raccourci par défaut des Code Templates est Ctrl+J. Vous pouvez saisir un identifiant, presser Ctrl+J et l'identifiant est remplacé par le texte défini pour cet identifiant. Des Code Templates peuvent être définis dans l'environnement - > Configuration - > Code Templates.
+
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.
  
Exemple : Écrivez 'classf ', laissez le curseur juste derrière le 'f ' et appuyez Ctrl+J. Le 'classf 'sera remplacé par
+
Exemple : écrivez 'classf ', laissez le curseur juste derrière le 'f ' et appuyez Ctrl+J. Le 'classf 'sera remplacé par
 
  T = class(T)
 
  T = class(T)
 
  private
 
  private
Line 100: Line 100:
 
  end;
 
  end;
 
et le curseur sera derrière le 'T'.
 
et le curseur sera derrière le 'T'.
Vous pouvez obtenir la liste de identifiant en plaçant le curseur sur un espace (pas sur un identifiant) et en appuyant Ctrl+J. La liste 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.
+
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.
  
 
Les plus grands économiseurs de temps sont les templates 'b'+Ctrl+J pour begin..end.
 
Les plus grands économiseurs de temps sont les templates 'b'+Ctrl+J pour begin..end.
Line 106: Line 106:
 
==Conseils de paramètre ==
 
==Conseils de paramètre ==
  
Les conseils de paramètre montre une boîte de conseil avec les déclarations de paramètre pour la liste courante de paramètre .
+
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 .
  
 
Par exemple  
 
Par exemple  
Line 112: Line 112:
 
  Canvas.FillRect(|);
 
  Canvas.FillRect(|);
  
Placer le curseur dans les parenthèses et la presser sur Ctrl+Shift+Space. Une boîte de conseil apparaîtra  montrant les paramètres de FillRect.
+
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.
  
 
==Complétion de code==
 
==Complétion de code==
 
Pour les Delphinautes :
 
Pour les Delphinautes :
Delphi appelle la "Complétion de code" la fonction montrant la liste des identifiant à la position courante du code source (Ctrl+Espace). Sous Lazarus cela s'appelle le "Complétion d'identificateur".
+
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".
  
 
La complétion de code combine de puissantes fonctions. Exemples :
 
La complétion de code combine de puissantes fonctions. Exemples :
* 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
+
* [[Lazarus_IDE_Tools/fr#Complétion de classe|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 ;
* Complétion de procédure vers l'avant : ajoute des corps de procédure
+
* [[Lazarus_IDE_Tools/fr#Complétion de procédure vers l'avant|Complétion de procédure vers l'avant]] : ajoute des corps de procédure ;
* 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
+
* [[Lazarus_IDE_Tools/fr#Complétion d'assignation d'événement|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 ;
* Complétion de Déclaration de Variable : ajoute des définitions de variables locales  
+
* [[Lazarus_IDE_Tools/fr#Complétion de déclaration de variable|Complétion de déclaration de variable]] : ajoute des définitions de variables locales.
  
 
La fonction utilisée dépend de la position du curseur dans l'éditeur.
 
La fonction utilisée dépend de la position du curseur dans l'éditeur.
  
Le Complétion de code peut être trouvé dans le menu de l'EDI Edition - > Complétion le code en utilisant le raccourci standard Ctrl+Maj+C.
+
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.
  
===Complément de classe===
+
===Complétion de classe===
  
Le dispositif de complément de code le plus puissant est "complément de classe". Vous écrivez une classe, ajoutez les méthodes et les propriétés et le complément de code ajoutera les corps de méthode, l'accès méthodes/variables de propriété et les variables privées.
+
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.
  
Par exemple : Créez une classe (voir les code templates pour savoir quel type) :
+
Par exemple : créez une classe (voir les code templates pour savoir quel type) :
  
 
  TExample = class(TObject)
 
  TExample = class(TObject)
Line 139: Line 139:
 
   destructor Destroy; override;
 
   destructor Destroy; override;
 
  end;
 
  end;
Placez le curseur quelque part dans la classe et appuyez Ctrl+Maj+C. Ceci créera les corps de méthodes manquants et déplacera le curseur au premier corps de méthode créé, ainsi vous pouvez juste commencer à écrire la classe :
+
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 :
  
 
  { TExample }
 
  { TExample }
Line 154: Line 154:
 
Note : '|' est le curseur et n'est pas à ajouter.
 
Note : '|' est le curseur et n'est pas à ajouter.
  
Conseil : Vous pouvez sauter entre une méthode et son corps avec Ctrl+Maj+Haut.
+
Conseil : vous pouvez sauter entre une méthode et son corps avec Ctrl+Maj+Haut.
  
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.
+
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.
  
 
Ajoutez maintenant une méthode DoSomething :
 
Ajoutez maintenant une méthode DoSomething :
Line 173: Line 173:
 
  end;
 
  end;
  
Vous constaterez, que le nouveau corps de méthode à é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éfini dans la classe. Vous pouvez définir la politique d'insertion dans l'environnement - > Configuration - > Création de code.
+
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.
  
 
'''Compléter les Propriétés'''<br>
 
'''Compléter les Propriétés'''<br>
Line 190: Line 190:
 
   FAnInteger:=AValue;
 
   FAnInteger:=AValue;
 
  end;
 
  end;
Le complément 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 :
+
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 :
 
  TExample = class(TObject)
 
  TExample = class(TObject)
 
  private
 
  private
Line 201: Line 201:
 
   property AnInteger: integer read FAnInteger write SetAnInteger;
 
   property AnInteger: integer read FAnInteger write SetAnInteger;
 
  end;
 
  end;
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 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 le modifier dans l'environnement -> Configuration - > Création de code.
+
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.
  
 
Une propriété créée pour la lecture seule :
 
Une propriété créée pour la lecture seule :
Line 222: Line 222:
  
 
Conseil :
 
Conseil :
Le complément d'identifiant reconnaît aussi des propriétés incomplètes et suggérera les noms implicites. Par exemple :
+
la complétion d'identificateur reconnaît aussi des propriétés incomplètes et suggérera les noms implicites. Par exemple :
 
  property PropName: PropType read |;
 
  property PropName: PropType read |;
Placez l'espace du curseur un derrière le mot-clé 'read' et appuyez Ctrl+Espace pour le complément d'identifiant. Il vous présentera la variable 'FPropName' et la procedure 'SetPropName '.
+
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 '.
  
===Complément de procédure vers l'avant===
+
===Complétion de procédure vers l'avant===
"Complément de procédure vers l'avant" fait partie du complément de code et ajoute les corps de procédures absentes. Il est appelé, quand le curseur est sur une procédure déjà définie.
+
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.
  
 
Par exemple :
 
Par exemple :
Line 237: Line 237:
 
   |
 
   |
 
  end;
 
  end;
Conseil : Vous pouvez sauter entre une définition de procédure et son corps avec Ctrl+Maj+Haut.
+
Conseil : vous pouvez sauter entre une définition de procédure et son corps avec Ctrl+Maj+Haut.
  
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 :
+
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 :
 
   procedure Proc1;
 
   procedure Proc1;
 
   procedure Proc2; // nouvelle procédure
 
   procedure Proc2; // nouvelle procédure
 
   procedure Proc3;
 
   procedure Proc3;
Si les corps de Proc1 et de Proc3 existe 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 - > Création de code.
+
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.
  
 
Procédures multiples :
 
Procédures multiples :
Line 251: Line 251:
 
  procedure Proc4_New; //  "
 
  procedure Proc4_New; //  "
 
  procedure Proc5_Old; // le corps existe
 
  procedure Proc5_Old; // le corps existe
Le complément de code ajoutera chacun des 3 corps de procédure (Proc2_New, Proc3_New, Proc4_New).
+
La complétion de code ajoutera chacun des 3 corps de procédure (Proc2_New, Proc3_New, Proc4_New).
  
Pourquoi l'appeler "Complément de procédure vers l'avant" ?
+
Pourquoi l'appeler "Complétion de procédure vers l'avant" ?
  
Parce qu'il fonctionne non seulement pour les procédures définies dans l'interface, mais aussi pour les procédures avec le spécificateur "Forward".  
+
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".
  
===Complément d'assignation d'événement===
+
===Complétion d'assignation d'événement===
"Le complément d'assignation d'événement" fait partie du complément de code Event : = NomMethode. Il est appelé, quand le curseur est derrière l'assignation d'un événement.
+
"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.
  
 
Par exemple :
 
Par exemple :
Dans une méthode, par exemple l'événement FormCreate, ajoutez une ligne 'OnPaint : = ':
+
dans une méthode, par exemple l'événement FormCreate, ajoutez une ligne 'OnPaint : = ':
 
  procedure TForm1.Form1Create(Sender: TObject);
 
  procedure TForm1.Form1Create(Sender: TObject);
 
  begin
 
  begin
Line 269: Line 269:
 
Appuyez sur Ctrl+Maj+C pour compléter le code. Le rapport sera rempli par
 
Appuyez sur Ctrl+Maj+C pour compléter le code. Le rapport sera rempli par
 
  OnPaint:=@Form1Paint;
 
  OnPaint:=@Form1Paint;
Une nouvelle méthode Form1Paint sera ajoutée à la classe TForm1. Alors le complément de classe est lancé et vous obtiendrez :
+
Une nouvelle méthode Form1Paint sera ajoutée à la classe TForm1. Alors la complétion de classe est lancée et vous obtiendrez :
 
  procedure TForm1.Form1Paint(Sender: TObject);
 
  procedure TForm1.Form1Paint(Sender: TObject);
 
  begin
 
  begin
Line 277: Line 277:
  
 
Note:<br>
 
Note:<br>
Vous devez placer le curseur derrière l'opérateur ': = '. Si vous placez le curseur sur l'identifiant (par exemple OnPaint) le complément de code appellera "le complément de variable local", qui échouera, car onPaint est déjà défini.
+
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.
  
 
Conseil :<br>
 
Conseil :<br>
Vous pouvez définir le nouveau nom de méthode par vous-même. Par exemple :
+
vous pouvez définir le nouveau nom de méthode par vous-même. Par exemple :
 
   OnPaint:=@ThePaintMethod;
 
   OnPaint:=@ThePaintMethod;
  
===Complément de déclaration de variable===
+
===Complétion de déclaration de variable===
Le "complément de déclaration de variable" fait partie du complément de code et ajoute une définition de variable locale pour un Identifiant:=ValeureAAffecter. Il est appelé, quand le curseur est sur l'identifiant d'une tâche ou d'un paramètre.
+
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.
  
 
Par exemple :
 
Par exemple :
Line 291: Line 291:
 
   i:=3;
 
   i:=3;
 
  end;
 
  end;
Placez le curseur sur le 'i' ou juste derrière lui. Appuyez alors Ctrl+Maj+C pour le complément de code et vous obtiendrez :
+
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 :
 
  procedure TForm1.Form1Create(Sender: TObject);
 
  procedure TForm1.Form1Create(Sender: TObject);
 
  var
 
  var
Line 298: Line 298:
 
   i:=3;
 
   i:=3;
 
  end;
 
  end;
Les outils de code font les première 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é à la variable à droite de l'opérateur ': = '.
+
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 ': = '.
  
 
Un autre exemple :
 
Un autre exemple :
Line 310: Line 310:
 
     for Where:=Low(a) to High(a) do writeln(a[Where]);
 
     for Where:=Low(a) to High(a) do writeln(a[Where]);
 
   end;
 
   end;
Placez le curseur sur 'Where' et appuyez sur Ctrl+Maj+C pour le complément de code. Vous obtenez :
+
Placez le curseur sur 'Where' et appuyez sur Ctrl+Maj+C pour la complétion de code. Vous obtenez :
 
   procedure TForm1.Form1Create(Sender: TObject);
 
   procedure TForm1.Form1Create(Sender: TObject);
 
   var
 
   var
Line 326: Line 326:
 
     end;
 
     end;
 
   end;
 
   end;
Placez le curseur sur 'x1 'et appuyez Ctrl+Maj+C pour le complément de code. Vous obtenez :
+
Placez le curseur sur 'x1 'et appuyez sur Ctrl+Maj+C pour la complétion de code. Vous obtenez :
 
   procedure TForm1.FormPaint(Sender: TObject);
 
   procedure TForm1.FormPaint(Sender: TObject);
 
   var
 
   var
Line 336: Line 336:
 
   end;
 
   end;
  
===Reversed Class Completion===
+
===Complétion inverse de classe===
  
"Reversed Class Completion" is part of the '''Code Completion''' and adds a private method declaration for the current method body. It is invoked, when the cursor is in a method body, not yet defined in the class.
+
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.
This feature is available since Lazarus 0.9.21.
+
Cette fonctionnalité est disponible depuis la version 0.9.21 de Lazarus.
  
For example:
+
Par exemple :
 
   procedure TForm1.DoSomething(Sender: TObject);
 
   procedure TForm1.DoSomething(Sender: TObject);
 
   begin
 
   begin
 
   end;
 
   end;
  
The method DoSomething is not yet declared in TForm1. Press Ctrl+Shift+C and the IDE will add "procedure DoSomething(Sender: TObject);" to the private methods of TForm1.
+
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.
  
For Delphians:
+
Pour les delphinautes :
Class completion works under Lazarus always in one way: From class interface to implementation or backwards/reversed from class implementation to interface. Delphi always invokes both directions. The Delphi way has the disadvantage, that if a typo will easily create a new method stub without noticing.
+
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.
===Commentaires et Complément de code===
+
 
Le complément de code essai de conserver les commentaires là où ils sont.
+
===Commentaires et Complétion de code===
 +
La complétion de code essaie de conserver les commentaires là où ils sont.
 
Par exemple :
 
Par exemple :
 
   FList: TList; // liste de TComponent
 
   FList: TList; // liste de TComponent
Line 369: Line 370:
 
   FInt: integer;
 
   FInt: integer;
  
==Retravailler (Refactoring)==
+
== Réusinage de code (Refactoring)==
  
 
===Inverser les assignations===
 
===Inverser les assignations===
  
;Résumé: "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 étend l'opération inverse de l'autre.  
+
;Résumé: "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.  
  
 
Exemple :<br>
 
Exemple :<br>
Line 382: Line 383:
 
   AValueHouse:=BValueHouse;
 
   AValueHouse:=BValueHouse;
 
  end;
 
  end;
Choisissez les lignes avec affectations (entre begin et end) et inversez les affectations. Toutes les affectations seront inversées et l'indentation sera ajoutée automatiquement. Par exemple :
+
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 :
  
 
Résultat :
 
Résultat :
Line 395: Line 396:
 
;Résumé: 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.  
 
;Résumé: 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.  
  
Exemple basic :<br>
+
Exemple basique :<br>
 
  procedure DoSomething;
 
  procedure DoSomething;
 
  begin
 
  begin
Line 410: Line 411:
 
   NewProc;
 
   NewProc;
 
  end;
 
  end;
Vous constaterez que la nouvelle procédure "NewProc" a été créé avec la sélection tandis que le vieux code à été remplacé par un appel à "NewProc".
+
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".
  
 
Variables locales et paramètres :<br>
 
Variables locales et paramètres :<br>
L'"Extraction de procédure" récupère les variables utilisées et crée automatiquement la liste de paramètres et les variables locales. Exemple :
+
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 :
 
  procedure TForm1.DoSomething(var Erni, Bert: integer);
 
  procedure TForm1.DoSomething(var Erni, Bert: integer);
 
  var
 
  var
Line 423: Line 424:
 
   end;
 
   end;
 
  end;
 
  end;
Sélectionnez la boucle for et créez une nouvelle procédure "NewProc". La variable locale i est seulement utilisée dans la sélection, ainsi elle sera déplacée dans la nouvelle procédure. Erni est également employé dans le code restant dans lequel il deviendra un paramètre.
+
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.
  
 
Résultat :<br>
 
Résultat :<br>
Line 441: Line 442:
 
  end;
 
  end;
  
Vous pouvez voir que "i" a été déplacé dans la nouvelle procédure (note : y compris son commentaire) et Erni.
+
Vous pouvez voir que "i" a été déplacée dans la nouvelle procédure (avec son commentaire), de même que Erni.
  
 
Limitations :<br>
 
Limitations :<br>
Le Pascal est un langage très puissant, ainsi cela fonctionnera avec sur chaque code. Les limites actuelles sont :
+
le Pascal est un langage très puissant, ainsi cela fonctionnera sur chaque code. Les limites actuelles sont :
* vérifiez si les limites de la sélection soit compatible avec la portée des variables
+
* qu'il vous faut vérifier que les limites de la sélection soient compatibles avec la portée des variables ;
* la déclaration "with"
+
* la déclaration "with".
 +
 
 
==Trouver la référence de l'identificateur==
 
==Trouver la référence de l'identificateur==
Placez le curseur sur un identifiant et "trouver la référence de l'identificateur". Alors elle recherchera la déclaration de cet identifiant, ouvrira le fichier et se positionnera dessus.
+
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 à un point de saut. Cela signifie que le saut peut se faire dans un sens ou dans l'autre avec Chercher -> En arrière.
+
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.
  
 
Il y a quelques différences avec Delphi :
 
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 :
+
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 :
  
La propriété "Visible" est d'abord définie dans TControl (controls.pp), ensuite 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 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.
+
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.
  
 
C'est également vrai pour des types comme Tcolor.
 
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
+
Pour le compilateur c'est simplement un "longint". Mais dans les sources, il est défini comme
 
  TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;
 
  TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;
 
  TColor = TGraphicsColor;
 
  TColor = TGraphicsColor;
Line 466: Line 468:
 
Trouver la déclaration de TWinControl saute à la définition précédente
 
Trouver la déclaration de TWinControl saute à la définition précédente
 
  TWinControl = class;
 
  TWinControl = class;
En l'appelant encore on atteint l'implémentation réel
+
En l'appelant encore on atteint l'implémentation réelle
 
  TWinControl = class(TControl)
 
  TWinControl = class(TControl)
De cette façon vous pouvez dépister chaque identifiant et trouver chaque surcharge.
+
De cette façon, vous pouvez dépister chaque identificateur et trouver chaque surcharge.
  
==Identifier Completion==
+
==complétion d'identificateur==
"Identifier Completion" is invoked by Ctrl+Space. It shows all identifiers in scope. For example:
+
La "complétion d'identificateur" est appelée par Ctrl+Space. Elle montre tous les identificateurs à portée. Par exemple :
  
 
   procedure TForm1.FormCreate(Sender: TObject);
 
   procedure TForm1.FormCreate(Sender: TObject);
Line 478: Line 480:
 
   end;
 
   end;
  
Place the cursor between ''begin'' and ''end'' and press Ctrl+Space. The IDE/CodeTools will now parse all reachable code and present you a list of all found identifiers. The CodeTools cache the results, so invoking it a second time will be much faster.
+
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 .
  
'''Note for Delphians:''' Delphi calls it ''Code completion''.
+
'''Note au utilisateurs de Delphi :''' Delphi l'appelle ''complétion de Code''.
  
Some identifiers like 'Write', 'ReadLn', 'Low', 'SetLength', 'Self', 'Result', 'Copy' are built into the compiler and are not defined anywhere in source. The identifier completion has a lot of these things built in as well. If you find one missing, just create a feature request in the bug tracker.
+
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 .
  
Identifier completion does not complete '''keywords'''. So you can not use it to complete 'proc' to 'procedure'. For these things use Ctrl+W [[#Word Completion|Word Completion]] instead or Ctrl+J [[#Code Templates|Code Templates]].
+
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 [[#Word Completion|complétion de mot]] au lieu de Ctrl+J [[#Code Templates|Code Templates]].
  
Identifier completion shows even those identifiers, that are not compatible.
+
La complétion d'identificateur montre même ces identificateurs, qui ne sont pas compatibles.
  
===Prefix===
+
===Préfixe ===
You can start identifier completion in a word. Then the letters to the left will be taken as prefix. For example:
+
Vous pouvez commencer la complétion d'identificateur en un mot. Alors les lettres vers la gauche seront prises comme préfixe. Par exemple :
  
 
   procedure TForm1.FormCreate(Sender: TObject);
 
   procedure TForm1.FormCreate(Sender: TObject);
Line 496: Line 498:
 
   end;
 
   end;
  
The box will show you only the identifiers beginning with 'Ca'.
+
La boîte vous montrera seulement les identificateurs commençant par 'Ca'.
  
===Keys===
+
===Touches===
  
* Letter or number: add the character to the source editor and the current prefix. This will update the list.
+
* Lettre ou nombre : ajouter le caractère à l'éditeur de source et le préfixe courant. Ceci mettra à jour la liste ;
* Backspace: remove the last character from source editor and prefix. Updates the list.
+
* Backspace: enlève le dernier caractère de l'éditeur de  source et le préfixe. Met à jour la liste ;
* Return: replace the whole word at cursor with the selected identifier and close the popup window.
+
* Entrée: remplace le mot entier au curseur avec l'identificateur choisi et ferme la fenêtre popup ;
* Shift+Return: as ''Return'', but replaces only the prefix (left part) of the word at the cursor.
+
* Shift+Entrée: comme ''Entrée'', mais remplace seulement le préfixe (partie gauche) du mot au curseur ;
* Up/Down: move selection
+
* Haut/Bas: déplace la sélection ;
* Escape: close popup without change
+
* Echap: Ferme le popup sans changement ;
* Tab: completes the prefix to next choice. For example: The current prefix is 'But' and the identifier completion only shows 'Button1' and 'Button1Click'. Then pressing ''Tab'' will complete the prefix to 'Button1'.
+
* 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' ;
* Else: as ''Return'' and add the character to the source editor
+
* Else: comme ''Entrée'' et ajoute le caractère à l'éditeur de source ;
  
==Complétion de mots==
+
==Complétion de mot==
La "complétion de mot" est appelée par Ctrl+W. Il montre tous les mots de tous les éditeurs actuellement ouverts.
+
La "complétion de mot" est appelée par Ctrl+W. Elle montre tous les mots de tous les éditeurs actuellement ouverts.
  
Autrement il travaille de la même manière que la complétion d'identificateur.
+
Sinon, elle travaille de la même manière que la complétion d'identificateur.
  
 
==Aller à la directive include==
 
==Aller à la directive include==
"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é.
+
"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é.
  
 
==Publier le Projet==
 
==Publier le Projet==
 
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.
 
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.
  
Le dossier (répertoire) d'un projet normal contient beaucoup d'information. La majeure partie n'est pas nécessaire pour être éditée : 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".
+
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".
  
'''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.
+
'''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.
  
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 archives.
+
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.
  
 
==Contributeurs originaux==
 
==Contributeurs originaux==
Line 530: Line 532:
 
* Page créée et modèle initial – 06/04/2004 [[User:Tom Lisjac| VlxAdmin]]
 
* Page créée et modèle initial – 06/04/2004 [[User:Tom Lisjac| VlxAdmin]]
 
* Contenu initial posté – 10/04/2004 MattiasG
 
* Contenu initial posté – 10/04/2004 MattiasG
* Petit wiki et fixation du formatage – 11/04/2004 [[User:Tom Lisjac| VlxAdmin]]
+
* Petit wiki et correction du formatage – 11/04/2004 [[User:Tom Lisjac| VlxAdmin]]
 
* Ajout d'un tableau synoptique pour des raccourcis des outils de l'EDI 12 juillet 2004 [[User:Kirkpatc]]
 
* Ajout d'un tableau synoptique pour des raccourcis des outils de l'EDI 12 juillet 2004 [[User:Kirkpatc]]

Latest revision as of 10:36, 28 September 2014

Deutsch (de) English (en) español (es) suomi (fi) français (fr) 日本語 (ja) 한국어 (ko) Nederlands (nl) português (pt) русский (ru) slovenčina (sk) 中文(中国大陆)‎ (zh_CN)

Vue d'ensemble

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).

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é.

Tableau synoptique des raccourcis de l'EDI

Saut de Déclaration Ctrl+Clic (saut à la déclaration du type ou de la variable)
Saut de Méthode Ctrl+Maj+Haut (basculer entre la définition et le corps)
Code Templates Ctrl+J
Complétion de code (Complétion de classe)   Ctrl+Maj+C
Complétion d'identificateur Ctrl+Espace
Complétion de Mot Ctrl+W
Conseils de paramètre Ctrl+Shift+Space

Saut de Méthode

Pour sauter du corps d'une procédure (begin..end) à sa définition (procédure NomProcedure;) utilisez Ctrl+Maj+Haut.

Par exemple :

interface

procedure DoSomething; // déclaration de la procédure
 
implementation
 
procedure DoSomething; // corps de la procédure 
begin
end;

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'.

Ceci fonctionne également avec les méthodes (procédures dans les classes).

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).

Par exemple une procédure avec différents types de paramètre :

interface

procedure DoSomething(p: char); // déclaration de la procédure

implementation
  
procedure DoSomething(p: string); // corps de la procédure
begin
end;

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.

Par exemple :
Vous avez renommé 'DoSomething' en 'MakeIt' :

interface

procedure MakeIt; // déclaration de la procédure

implementation

procedure DoSomething; // corps de la procédure
begin
end;

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.

Fichiers d'inclusion

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.

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.

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.

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.

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.

Ce mécanisme a naturellement des limites. Certains fichiers d'inclusion sont inclus deux fois ou plus. Par exemple : lcl/include/winapih.inc.

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. ;)

Code Templates

Les Code Templates convertissent un identificateur en texte ou en fragment de code.

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.

Exemple : écrivez 'classf ', laissez le curseur juste derrière le 'f ' et appuyez Ctrl+J. Le 'classf 'sera remplacé par

T = class(T)
private

public
  constructor Create;
  destructor Destroy; override;
end;

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.

Les plus grands économiseurs de temps sont les templates 'b'+Ctrl+J pour begin..end.

Conseils de paramètre

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 .

Par exemple

Canvas.FillRect(|);

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.

Complétion de code

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".

La complétion de code combine de puissantes fonctions. Exemples :

La fonction utilisée dépend de la position du curseur dans l'éditeur.

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.

Complétion de classe

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.

Par exemple : créez une classe (voir les code templates pour savoir quel type) :

TExample = class(TObject)
public
  constructor Create;
  destructor Destroy; override;
end;

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 :

{ TExample }

constructor TExample.Create;
begin
  |
end;

destructor TExample.Destroy;
begin
  inherited Destroy;
end;

Note : '|' est le curseur et n'est pas à ajouter.

Conseil : vous pouvez sauter entre une méthode et son corps avec Ctrl+Maj+Haut.

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.

Ajoutez maintenant une méthode DoSomething :

TExample = class(TObject)
public
  constructor Create;
  procedure DoSomething(i: integer);
  destructor Destroy; override;
end;

Ensuite pressez Ctrl+Maj+C et l'EDI ajoutera

procedure TExample.DoSomething(i: integer);
begin
  |
end;

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.

Compléter les Propriétés
Ajoutez une propriété AnInteger :

TExample = class(TObject)
public
  constructor Create;
  procedure DoSomething(i: integer);
  destructor Destroy; override;
  property AnInteger: Integer;
end;

Appuyez Ctrl+Maj+C et vous obtiendrez :

procedure TExample.SetAnInteger(const AValue: integer);
begin
  |if FAnInteger=AValue then exit;
  FAnInteger:=AValue;
end;

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 :

TExample = class(TObject)
private
  FAnInteger: integer;
  procedure SetAnInteger(const AValue: integer);
public
  constructor Create;
  procedure DoSomething(i: integer);
  destructor Destroy; override;
  property AnInteger: integer read FAnInteger write SetAnInteger;
end;

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.

Une propriété créée pour la lecture seule :

property PropName: PropType read;

sera étendue en

property PropName: PropType read FPropName;

Une propriété créée en écriture seule

 property PropName: PropType write;

sera étendue en

property PropName: PropType write SetPropName;

Une propriété créée en lecture seule avec une méthode read

property PropName: PropType read GetPropName;

sera conservée et la fonction GetPropName sera ajoutée

function GetpropName: PropType;

Créer une propriété avec un spécificateur de stockage

property PropName: PropType stored;

sera étendue en

property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;

Puisque le stockage est utilisé pour les spécificateurs de flux de lecture/écriture le code est complété en fonction.

Conseil : la complétion d'identificateur reconnaît aussi des propriétés incomplètes et suggérera les noms implicites. Par exemple :

property PropName: PropType read |;

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 '.

Complétion de procédure vers l'avant

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.

Par exemple : Ajoutez une nouvelle procédure dans la section interface :

procedure DoSomething;

Placez le curseur dessus et appuyez Ctrl+Maj+C pour compléter le code. Elle sera crée dans la section implémentation :

procedure DoSomething;
begin
  |
end;

Conseil : vous pouvez sauter entre une définition de procédure et son corps avec Ctrl+Maj+Haut.

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 :

 procedure Proc1;
 procedure Proc2; // nouvelle procédure
 procedure Proc3;

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.

Procédures multiples :

procedure Proc1_Old; // le corps existe
procedure Proc2_New; // le corps n'existe pas
procedure Proc3_New; //  "
procedure Proc4_New; //  "
procedure Proc5_Old; // le corps existe

La complétion de code ajoutera chacun des 3 corps de procédure (Proc2_New, Proc3_New, Proc4_New).

Pourquoi l'appeler "Complétion de procédure vers l'avant" ?

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".

Complétion d'assignation d'événement

"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.

Par exemple : dans une méthode, par exemple l'événement FormCreate, ajoutez une ligne 'OnPaint : = ':

procedure TForm1.Form1Create(Sender: TObject);
begin
  OnPaint:=|
end;

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

OnPaint:=@Form1Paint;

Une nouvelle méthode Form1Paint sera ajoutée à la classe TForm1. Alors la complétion de classe est lancée et vous obtiendrez :

procedure TForm1.Form1Paint(Sender: TObject);
begin
  |
end;

Ceci fonctionne seulement pour ajouter des méthodes dans l'inspecteur d'objet.

Note:
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.

Conseil :
vous pouvez définir le nouveau nom de méthode par vous-même. Par exemple :

 OnPaint:=@ThePaintMethod;

Complétion de déclaration de variable

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.

Par exemple :

procedure TForm1.Form1Create(Sender: TObject);
begin
  i:=3;
end;

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 :

procedure TForm1.Form1Create(Sender: TObject);
var
  i: Integer;
begin
  i:=3;
end;

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 ': = '.

Un autre exemple :

type
 TWhere = (Behind, Middle, InFront);

 procedure TForm1.Form1Create(Sender: TObject);
 var
   a: array[TWhere] of char;
 begin
   for Where:=Low(a) to High(a) do writeln(a[Where]);
 end;

Placez le curseur sur 'Where' et appuyez sur Ctrl+Maj+C pour la complétion de code. Vous obtenez :

 procedure TForm1.Form1Create(Sender: TObject);
 var
   a: array[TWhere] of char;
   Where: TWhere;
 begin
   for Where:=Low(a) to High(a) do writeln(a[Where]);
 end;

Depuis la version 0.9.11 Lazarus complète également des paramètres. Par exemple

 procedure TForm1.FormPaint(Sender: TObject);
 begin
   with Canvas do begin
     Line(x1,y1,x2,y2);
   end;
 end;

Placez le curseur sur 'x1 'et appuyez sur Ctrl+Maj+C pour la complétion de code. Vous obtenez :

 procedure TForm1.FormPaint(Sender: TObject);
 var
   x1: integer;
 begin
   with Canvas do begin
     Line(x1,y1,x2,y2);
   end;
 end;

Complétion inverse de classe

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.

Par exemple :

 procedure TForm1.DoSomething(Sender: TObject);
 begin
 end;

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.

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.

Commentaires et Complétion de code

La complétion de code essaie de conserver les commentaires là où ils sont. Par exemple :

 FList: TList; // liste de TComponent
 FInt: integer;

En insérant une nouvelle variable entre FList et FInt, le commentaire est maintenu dans la ligne de FList. C'est également vrai pour

 FList: TList; { list of TComponent
   This is a comment over several lines, starting
   in the FList line, so codetools assumes it belongs 
   to the FLIst line and will not break this 
   relationship. Code is inserted behind the comment. }
 FInt: integer;

Si le commentaire commence à la ligne suivante :

 FList: TList; // liste de TComponent
   { This comment belongs to the statement below. 
     New code is inserted above this comment and 
     behind the comment of the FList line. }
 FInt: integer;

Réusinage de code (Refactoring)

Inverser les assignations

Résumé
"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.

Exemple :

procedure DoSomething;
begin
  AValueStudio:= BValueStudio;
  AValueAppartment :=BValueAppartment;
  AValueHouse:=BValueHouse;
end;

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 :

Résultat :

procedure DoSomething;
begin
  BValueStudio     := AValueStudio;
  BValueAppartment := AValueAppartment;
  BValueHouse      := AValueHouse;
end;

Procédure d'extraction

Résumé
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.

Exemple basique :

procedure DoSomething;
begin
  CallSomething;
end;

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 :

procedure NewProc;
begin
  CallSomething;
end;

procedure DoSomething;
begin
  NewProc;
end;

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".

Variables locales et paramètres :
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 :

procedure TForm1.DoSomething(var Erni, Bert: integer);
var
  i: Integer; // Commentaire
begin
  Erni:=Erni+Bert;
  for i:=Erni to 5 do begin
  |
  end;
end;

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.

Résultat :

procedure NewProc(const Erni: integer);
var
  i: Integer; // Commentaire
begin
  for i:=Erni to 5 do begin
  |
  end;
end;

procedure TForm1.DoSomething(var Erni, Bert: integer);
begin
  Erni:=Erni+Bert;
  NewProc(Erni);
end;

Vous pouvez voir que "i" a été déplacée dans la nouvelle procédure (avec son commentaire), de même que Erni.

Limitations :
le Pascal est un langage très puissant, ainsi cela fonctionnera sur chaque code. Les limites actuelles sont :

  • qu'il vous faut vérifier que les limites de la sélection soient compatibles avec la portée des variables ;
  • la déclaration "with".

Trouver la référence de l'identificateur

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.

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 :

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.

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

TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;
TColor = TGraphicsColor;

Il en va de même pour les classes précédentes : Par exemple dans TControl, il y a une variable privée

FHostDockSite: TWinControl;

Trouver la déclaration de TWinControl saute à la définition précédente

TWinControl = class;

En l'appelant encore on atteint l'implémentation réelle

TWinControl = class(TControl)

De cette façon, vous pouvez dépister chaque identificateur et trouver chaque surcharge.

complétion d'identificateur

La "complétion d'identificateur" est appelée par Ctrl+Space. Elle montre tous les identificateurs à portée. Par exemple :

 procedure TForm1.FormCreate(Sender: TObject);
 begin
   |
 end;

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 .

Note au utilisateurs de Delphi : Delphi l'appelle complétion de Code.

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 .

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.

La complétion d'identificateur montre même ces identificateurs, qui ne sont pas compatibles.

Préfixe

Vous pouvez commencer la complétion d'identificateur en un mot. Alors les lettres vers la gauche seront prises comme préfixe. Par exemple :

 procedure TForm1.FormCreate(Sender: TObject);
 begin
   Ca|ption
 end;

La boîte vous montrera seulement les identificateurs commençant par 'Ca'.

Touches

  • Lettre ou nombre : ajouter le caractère à l'éditeur de source et le préfixe courant. Ceci mettra à jour la liste ;
  • Backspace: enlève le dernier caractère de l'éditeur de source et le préfixe. Met à jour la liste ;
  • Entrée: remplace le mot entier au curseur avec l'identificateur choisi et ferme la fenêtre popup ;
  • Shift+Entrée: comme Entrée, mais remplace seulement le préfixe (partie gauche) du mot au curseur ;
  • Haut/Bas: déplace la sélection ;
  • Echap: Ferme le popup sans changement ;
  • 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' ;
  • Else: comme Entrée et ajoute le caractère à l'éditeur de source ;

Complétion de mot

La "complétion de mot" est appelée par Ctrl+W. Elle montre tous les mots de tous les éditeurs actuellement ouverts.

Sinon, elle travaille de la même manière que la complétion d'identificateur.

Aller à la directive include

"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é.

Publier le Projet

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.

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".

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.

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.

Contributeurs originaux

Cette page a été convertie de la version d'epikwiki version.

  • Page créée et modèle initial – 06/04/2004 VlxAdmin
  • Contenu initial posté – 10/04/2004 MattiasG
  • Petit wiki et correction du formatage – 11/04/2004 VlxAdmin
  • Ajout d'un tableau synoptique pour des raccourcis des outils de l'EDI 12 juillet 2004 User:Kirkpatc