Difference between revisions of "Lazarus IDE Tools/fr"

From Lazarus wiki
Jump to navigationJump to search
Line 9: Line 9:
 
{|
 
{|
 
|-
 
|-
| [[Lazarus_IDE_Tools#Find Declaration|Saut de Déclaration]] || Ctrl+Clic (saut à la déclaration du type ou de la variable)
+
| [[Lazarus_IDE_Tools/fr#Find Declaration|Saut de Déclaration]] || Ctrl+Clic (saut à la déclaration du type ou de la variable)
 
|-
 
|-
| [[Lazarus_IDE_Tools#Method Jumping|Saut de Méthode]] || Ctrl+Maj+Haut (basculer entre la définition et le corps)
+
| [[Lazarus_IDE_Tools/fr#Method Jumping|Saut de Méthode]] || Ctrl+Maj+Haut (basculer entre la définition et le corps)
 
|-
 
|-
| [[Lazarus_IDE_Tools#Code Templates|Code Templates]] || Ctrl+J
+
| [[Lazarus_IDE_Tools/fr#Code Templates|Code Templates]] || Ctrl+J
 
|-
 
|-
| [[Lazarus_IDE_Tools#Code Completion|Complément de code]] (Complément de classe)   || Ctrl+Maj+C
+
| [[Lazarus_IDE_Tools/fr#Code Completion|Complément de code]] (Complément de classe)   || Ctrl+Maj+C
 
|-
 
|-
| [[Lazarus_IDE_Tools#Identifier Completion|Complément d'identifiant]] || Ctrl+Espace
+
| [[Lazarus_IDE_Tools/fr#Identifier Completion|Complément d'identifiant]] || Ctrl+Espace
 
|-
 
|-
| [[Lazarus_IDE_Tools#Word Completion|Word Completion]] || Ctrl+W
+
| [[Lazarus_IDE_Tools/fr#Word Completion|Word Completion]] || Ctrl+W
 
|-
 
|-
| [[Lazarus_IDE_Tools#Parameter Hints|Parameter Hints]] || Ctrl+Shift+Space
+
| [[Lazarus_IDE_Tools/fr#Parameter Hints|Parameter Hints]] || Ctrl+Shift+Space
 
|}
 
|}
  

Revision as of 10:50, 4 July 2007

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

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

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ément de code (Complément de classe)   Ctrl+Maj+C
Complément d'identifiant Ctrl+Espace
Word Completion Ctrl+W
Parameter Hints Ctrl+Shift+Space

Saut de Méthode

Pour sauter du corps d'une procedure (begin..end) et sa définition (procedure 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 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 sais 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é 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.

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 le complément de code, considèrent les fichiers d'inclusion en tant que marqueurs spéciaux.

Par exemple : Quand le complément 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.

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 ou plusieurs fois. 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. ;)

Code Templates

Les Code Templates convertissent un identifiant 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.

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

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

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 .

Par exemple

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.

Complément de code

Pour les Delphinautes : Delphi appelle le "Complément de code" la fonction montrant la liste des identifiant à la position courante du code source (Ctrl+Espace). Sous Lazarus cela s'appelle le "Complément d'identifiant".

Le complément de code combine de puissantes fonctions. Exemples :

  • Complément de classe : complète des propriétés, ajoute des corps de méthode, ajoute des variables et des méthodes privées
  • Complément de procédure vers l'avant : ajoute des corps de procédure
  • Complément d'assignation d'événement : complète les assignation d'événement et ajoute la définition et le corps de la méthode
  • Complément 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.

Le Complément de code peut être trouvé dans le menu de l'EDI Edition - > Compléter le code en utilisant le raccourci standard Ctrl+Maj+C.

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

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

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;

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 :

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

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 : Le complément d'identifiant 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 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 '.

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

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

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

Le complément 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" ?

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

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

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 le complément de classe est lancé 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'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.

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

 OnPaint:=@ThePaintMethod;

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

Par exemple :

procedure TForm1.Form1Create(Sender: TObject);
begin
  i:=3;
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 :

procedure TForm1.Form1Create(Sender: TObject);
var
  i: Integer;
begin
  i:=3;
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 ': = '.

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 le complément 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 Ctrl+Maj+C pour le complément de code. Vous obtenez :

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

Reversed Class Completion

"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. This feature is available since Lazarus 0.9.21.

For example:

 procedure TForm1.DoSomething(Sender: TObject);
 begin
 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.

For Delphians: 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.

Commentaires et Complément de code

Le complément de code essai 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;

Retravailler (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 étend l'opération inverse de l'autre.

Exemple :

procedure DoSomething;
begin
  AValueStudio:= BValueStudio;
  AValueAppartment :=BValueAppartment;
  AValueHouse:=BValueHouse;
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 :

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 basic :

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éé avec la sélection tandis que le vieux code à é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 de 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 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.

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é dans la nouvelle procédure (note : y compris son commentaire) et Erni.

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

  • vérifiez si les limites de la sélection soit compatible avec la portée des variables
  • la déclaration "with"

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

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

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

TWinControl = class(TControl)

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

Identifier Completion

"Identifier Completion" is invoked by Ctrl+Space. It shows all identifiers in scope. For example:

 procedure TForm1.FormCreate(Sender: TObject);
 begin
   |
 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.

Note for Delphians: Delphi calls it Code completion.

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.

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 instead or Ctrl+J Code Templates.

Identifier completion shows even those identifiers, that are not compatible.

Prefix

You can start identifier completion in a word. Then the letters to the left will be taken as prefix. For example:

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

The box will show you only the identifiers beginning with 'Ca'.

Keys

  • Letter or number: add the character to the source editor and the current prefix. This will update the list.
  • Backspace: remove the last character from source editor and prefix. Updates the list.
  • Return: replace the whole word at cursor with the selected identifier and close the popup window.
  • Shift+Return: as Return, but replaces only the prefix (left part) of the word at the cursor.
  • Up/Down: move selection
  • Escape: close popup without change
  • 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'.
  • Else: as Return and add the character to the source editor

Word Completion

"Word Completion" is invoked by Ctrl+W. It shows all words of all currently open editors.

Otherwise works the same as identifier completion.

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

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.

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 fixation du formatage – 11/04/2004 VlxAdmin
  • Ajout d'un tableau synoptique pour des raccourcis des outils de l'EDI 12 juillet 2004 User:Kirkpatc