Lazarus IDE Tools/fr

From Lazarus wiki
Jump to navigationJump to search

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étion de code (Complétion de classe)   Ctrl+Maj+C
Complétion d'identificateur Ctrl+Espace
Complétion de Mot 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 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.

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

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

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.

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 le complétion 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;

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 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 : 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 un derrière le mot-clé 'read' et appuyez Ctrl+Espace pour la complétion d'identificateur. Il vous présentera la variable 'FPropName' et la procedure '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 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

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'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étion d'assignation d'événement

"La complétion d'assignation d'événement" fait partie de la complétion 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 la complétion 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'identificateur (par exemple OnPaint) la complétion de code appellera "la complétion de variable locale", 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é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. Il est appelé, 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 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è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 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 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;

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étion de code

La complétion 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 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.

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 identificateur et trouver chaque surcharge.

complétion d'identificateur

La "complétion d'identificateur" est appelé par Ctrl+Space. Il 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 completion 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 compatible .

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: enleve 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 choisie 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: come 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. Il 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.

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