Lazarus IDE Tools/fr

From Free Pascal wiki
Jump to: navigation, 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, 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