Introduction

Cet article a pour but de recenser non pas tous les raccourcis claviers et outils de Delphi, mais un certain nombre d'entre eux qui m'auront semblés les plus utiles, en les classant par catégorie et en les accompagnant d'une brève description.
L'article s'adresse autant aux débutants qui souhaitent apprendre les différentes méthodes pour gagner du temps dans Delphi qu'aux Delphistes plus confirmés qui trouveront peut-être ici de quoi optimiser encore plus leur utilisation de l'IDE.

Evidemment tous ces raccourcis et outils ne serviront pas à tout le monde. Chacun devrait trouver chaussure à son pied dans cette sélection, selon sa manière d'utiliser Delphi : petites applications, gros développement, design d'interfaces ou au contraire beaucoup de code et moins de fiches...
Afin de fournir un panel véritablement intéressant de raccourcis et d'outils, je vous invite à m'envoyer par message privé ceux que vous connaissez que j'aurais omis, en l'accompagnant si besoin est d'une description de son utilité et de son fonctionnement (pour les outils).

Attention cet article ne concerne pas les outils tiers qui s'intègrent à Delphi comme les experts et autres assistants.

I. Exécution/Débogage

I-1. Raccourcis clavier

F9
Peut-être l'un des plus connus de tous. Il permet simplement de lancer votre application et éventuellement, avant cela, de la compiler si c'est nécessaire. La recompilation n'a lieu que si vous avez effectué un changement dans votre code depuis la dernière exécution.

Ctrl+F9
Ce raccourci permet de compiler votre projet. Succintement, cela signifie vérification de la syntaxe et construction de l'exécutable.
Vous pouvez visualiser la progression de la compilation en cochant l'option "Afficher la progression" (décochée par défaut) dans "Outils | Options d'environnement", à l'onglet "Préférences".

F4
Lorsque vous souhaitez déboguer votre application, ce raccourci peut être utile. Il permet d'exécuter le programme jusqu'à la ligne de code sur laquelle se trouve votre curseur dans l'éditeur. Vous pouvez ainsi vous rendre rapidement à un endroit particulier de votre code pour le déboguer.

F5
Utilisez cette touche dans l'éditeur, elle permettra de positionner un point d'arrêt sur la ligne active de votre code, ou d'enlever l'existant s'il y en a un.

F8
Une fois l'exécution de votre programme stoppée à l'encontre, soit de la ligne de code choisie avant de presser F4, soit d'un point d'arrêt, vous pouvez tracer dans le code de votre application en utilisant F8, "tracer" signifiant exécuter votre programme pas-à-pas, ligne de code par ligne de code.

F7
Même fonction que la touche F8, si ce n'est qu'en utilisant F7 vous parcourerez également pas-à-pas le code des éventuelles routines appelées à partir de votre programme.

Afin de bien comprendre la différence entre ces deux fonctionnalités, considérons le code suivant...

 
Sélectionnez

   function Exposant(A, B: Integer): Integer;
   var 
     i: Integer;
1: begin
2:   Result := 1;
   
3:   for i := 1 to B do
4:     Result := Result * A;
5: end;

   procedure TForm1.Button1Click(Sender: TObject);
   var
     A, B, Resultat: Integer;
6: begin
7:   A := Random(1000) + 1;
8:   B := Random(11);
9:   Resultat := Exposant(A, B);
     ...
   end;

... et imaginons que l'exécution ait été stoppée à la ligne 6.

Des appuis successifs sur F7 vous mèneront aux lignes 7, 8, 9 puis à l'intérieur de la fonction Exposant, aux lignes 1, 2, 3, 4 et 5 (Les lignes 3 et 4 étant exécutées B fois). Une fois la ligne 5 passée, vous retournerez à la ligne 10 puis exécuterez la fin de la procédure.

En utilisant la touche F8, vous exécuterez de la même manière les lignes 7 et 8, mais l'exécution de la ligne 9 ne vous fera pas passer dans le code de la fonction Exposant. Elle sera exécutée dans sa totalité, puis vous pourrez poursuivre l'exécution de la procédure.

Ctrl+F2
Ce raccourci permet de forcer la fermeture de votre programme par Delphi. En cas de plantage il peut s'avérer très utile.
Si vous ne pouvez plus fermer votre application alors qu'elle a été lancée par Delphi par exemple, il est très déconseillé de tuer le processus en utilisant le Gestionnaire des Tâches de Windows. En effet cela fait littéralement planter Delphi, du fait qu'il ne trouve plus le processus qu'il était en train de déboguer. Un redémarrage de la machine est souvent nécessaire lors d'un tel plantage, c'est pourquoi il vaut mieux utiliser Ctrl+F2 !

Ctrl+Click
Pendant un débogage, en cliquant sur un nom de variable et en maintenant Ctrl enfoncée, Delphi ouvre l'inspecteur de débogage sur l'élément cliqué. (voir le paragraphe suivant : "Les points de suivi")

Ctrl+F5
Cette combinaison de touches doit être utilisée lorsque votre curseur est placé sur un nom de variable dans votre code.
Il permet d'ajouter cette variable aux points de suivi, très utiles lors d'un débogage pour suivre l'évolution des valeurs que prennent vos différentes variables.

I-2. Les points de suivi

Nous allons détailler ici le fonctionnement des points de suivi.
Si votre curseur n'est pas situé sur un identificateur de variable lorsque vous utilisez Ctrl+F5, vous obtenez la fenêtre suivante :

Ajout/Modification d'un point de suivi
Ajout/Modification d'un point de suivi

Cette fenêtre permet de choisir des options différentes de celles par défaut pour votre point de suivi :

  • Nom du groupe : Nom du groupe de points de suivi auquel appartient celui que vous souhaitez ajouter ou que vous modifiez. Vous pouvez entrer le nom d'un nouveau groupe. Chaque nouveau groupe crée un nouvel onglet dans la fenêtre listant les points de suivi.
  • Répétitions : Spécifiez ici le nombre d'éléments que vous voulez afficher si votre point de suivi est un tableau. Si vous laissez 0, tout le tableau sera affiché.
  • Chiffres : Renseigne le nombre de chiffres significatifs si votre point de suivi est un nombre à virgule flottante.
  • Activé : Cochée par défaut, cette case indique que le point de suivi est actif ou non. S'il est inactif, Delphi ne cherchera pas à évaluer sa valeur et vous gagnerez ainsi sensiblement en performances lors du débogage.
  • Autoriser les appels de fonctions : Si cette case est cochée, le débogueur évaluera les points de suivi qui nécessitent l'appel d'une ou plusieurs fonctions. Dans le cas contraire il n'appellera pas ces fonctions et affichera "Valeur inaccessible".
  • Format d'affichage : Les boutons radio regroupés en bas de la fenêtre permettent de choisir un format d'affichage pour votre point de suivi. Chacun est adapté à la représentation d'un format de données particulier. Référez-vous aux rubriques "Formatage des expressions de suivi" et "Types de formats des propriétés de suivi" de l'aide de Delphi pour plus de détails.

Afin de visualiser les valeurs de vos points de suivi, vous pouvez afficher leur liste grâce au raccourci Ctrl+Alt+W, ou en y accédant par le menu : "Voir | Fenêtres de débogage | Points de suivi".

Voici un aperçu de cette fenêtre lors du débogage de la fonction Exposant. Des points de suivi ont été ajoutés sur les variables A, B et Result, ce qui permet de voir leur contenu :

Suivi des variables A, B et Result
Suivi des variables A, B et Result

Dans cette fenêtre, les coches servent à activer ou désactiver chacun des points de suivi. Si vous double-cliquez sur l'un d'entre eux, cela ouvre la fenêtre de ses propriétés que vous pouvez alors modifier.
En cliquant droit sur un point de suivi, vous ouvrez un menu déroulant qui vous propose plusieurs options, dont l'item "Inspecter". Inspecter un point de suivi revient à en visualiser le contenu, mais permet aussi de le modifier.
Toujours en débogant la fonction Exposant, il est donc possible de modifier la valeur de B pour changer l'exposant auquel va être élevé A. Il suffit pour cela de cliquer sur le bouton "..." en face de la valeur de B et d'effectuer votre changement.

Modifier la valeur d'un point de suivi
Modifier la valeur d'un point de suivi

Vous remarquerez au passage que l'inspecteur de débogage indique l'adresse à laquelle se trouve chaque variable. Dans notre cas,
B est stockée dans le registre processeur EDX.
Cet inspecteur peut être utilisé avec des classes, des enregistrements ou autres types de données complexes pour en afficher un certain nombre de détails.
Il peut être affiché en maintenant Ctrl enfoncée et en effectuant un click sur l'identificateur à examiner.

II. Conception de fiches

II-1. Raccourcis clavier

F11
Ce raccourci permet de naviguer entre la fiche en cours, son unité de code et l'inspecteur d'objets. Si c'est votre fiche qui était active, un appui sur F11 activera l'inspecteur d'objets, et un nouvel appui vous fera passer à l'unité. Cet ordre est inversé si vous avez appuyé la première fois sur F11 lorsque la fenêtre de l'unité était active.

Shift+F12
Ce raccourci affiche la liste des fiches en cours de design et vous permet de sélectionner celles que vous souhaitez visualiser.

Ctrl+Flèches directionnelles
Lorsqu'un ou plusieurs composants sont sélectionnés sur votre fiche, utilisez les flèches directionnelles en maintenant Ctrl enfoncée pour les déplacer pixel par pixel.

Ctrl+Shift+Flèches directionnelles
En maintenant Shift enfoncée en plus de Ctrl, vous déplacez vos composants colonne par colonne ou ligne par ligne sur la grille de votre fiche.

Shift+Flèches directionnelles
Utilisez les flèches directionnelles tout en appuyant sur Shift pour redimensionner un ou plusieurs composant, pixel par pixel.

Ctrl+Rectangle de sélection
Lorsque certains de vos composants sont à l'intérieur de conteneurs comme une GroupBox ou un Panel, vous ne pouvez pas effectuer un rectangle de sélection directement en cliquant dans le conteneur et en glissant. Cela n'aurait pour seul effet que de déplacer le conteneur.
Pour sélectionner des composants à l'intérieur d'un conteneur au moyen d'un rectangle de sélection, il faut donc maintenir la touche Ctrl enfoncée tout en traçant le rectangle.

II-2. La vue arborescente des objets

L'arborescence d'objets est une petite fenêtre qui peut venir compléter l'inspecteur d'objets.
Elle liste simplement tous les composants présents sur votre fiche active, et permet de voir d'un coup d'oeil les dépendances entre chacun d'eux.

Vous pouvez l'afficher grâce au raccourci Shift+Ctrl+F11 ou par le menu "Voir".

Vue arborescente des objets
Vue arborescente des objets

Sur cet exemple, on voit clairement que les composants Button1 et Edit3 sont contenu dans GroupBox1.
Un simple glisser-lâcher permettrait d'y déplacer également le composant Edit1, par exemple.

La sélection d'un composant dans la vue arborescente des objets a pour effet de le sélectionner également sur la fiche, et d'afficher ses propriétés dans l'inspecteur d'objets. Il est possible à partir de cette fenêtre de supprimer le composant sélectionné, en cliquant sur le bouton approprié.

II-3. La palette d'alignement

La palette d'alignement est une petite fenêtre fort pratique accessible par le menu "Voir", et qui comporte une dizaine de boutons :

Palette d'alignement
Palette d'alignement

Ce boutons servent -vous l'aurez compris- à aligner les composants sur votre fiche, entre eux ou par rapport au centre de la fiche.

Voyons en détail l'action de chacun de ces boutons :

Aligner à gauche
Aligne les bords gauches des composants sélectionnés.

Aligner en haut
Aligne les bords supérieurs des composants sélectionnés.

Aligner les centres horizontalement
Déplace horizontalement les composants pour que leurs centres soient alignés sur la même verticale.

Aligner les centres verticalement
Déplace verticalement les composants pour que leurs centres soient alignés sur la même horizontale.

Aligner horizontalement dans la fiche
Déplace horizontalement les composants sélectionnés pour qu'ils soient au centre de leur conteneur.
Cela inclut les Panel, GroupBox, ScrollBox etc.
Si plusieurs composants sont sélectionnés, c'est le groupe de composants qui est centré, et non chacun d'eux individuellement.

Aligner verticalement dans la fiche
Déplace verticalement les composants sélectionnés pour qu'ils soient au centre de leur conteneur.
Si plusieurs composants sont sélectionnés, c'est le groupe de composants qui est centré, et non chacun d'eux individuellement.

Espacer régulièrement, horizontalement
Fonctionne avec trois composants sélectionnés au minimum. Ce bouton permet de répartir horizontalement de manière uniforme les composants sélectionnés. Le composant à l'extrême gauche et celui à l'extrême droite ne bougent pas, ils servent de "borne" à ce répartissement.

Espacer régulièrement, veticalement
Même chose que ci-dessus, mais de manière verticale.

Aligner à droite
Aligne les bords droits des composants sélectionnés.

Aligner en bas
Aligne les bords inférieurs des composants sélectionnés.

Notez que pour les quatre premiers alignements ainsi que pour les deux derniers, c'est toujours le premier composant sélectionné qui sert de référence à l'alignement ; seuls les suivants sont donc déplacés.

III. Edition du code

Etant donnée la richesse de l'éditeur de Delphi en raccourcis et outils, ils seront ici distingués en trois catégories :

  • Saisie du code / Aide à la programmation
  • Navigation dans le code
  • Sélection / Recherche dans le code

III-1. Saisie du code / Aide à la programmation

III-1-a. Raccourcis clavier

Ctrl+Espace
Ce raccourci appelle la fenêtre d'achèvement du code. Elle permet d'afficher la liste des variables, procédures (...) susceptibles d'être utilisées au moment où vous déclenchez son ouverture.
Vous pouvez l'appeler lorsque vous avez commencé à taper le nom d'un identificateur pour en afficher l'orthographe et en terminer automatiquement la frappe, ou alors pour trouver une méthode, une propriété dans une classe ou un champ dans un record. Par défaut la fenêtre d'achèvement du code s'affiche automatiquement lorsque vous tapez un "." après un identificateur de classe ou de record.

Ctrl+Shift+Espace
Utilisez ce raccourci à l'intérieur des parenthèses d'une procédure ou d'une fonction, il affichera -s'ils n'étaient pas déjà visibles- les paramètres de la routine dans une bulle d'aide. Cela évite d'avoir à effacer et réouvrir la parenthèse de votre fonction lorsque cette bulle d'aide s'efface.

Ctrl+Shift+C
Avec cette combinaison de touches vous pouvez gagner un temps précieux. Elle permet de compléter la classe sous le curseur :
Si dans la déclaration d'une classe vous ajoutez par exemple une procédure ou une fonction, laissez votre curseur à l'intérieur de la déclaration de cette classe et utilisez le raccourci. Delphi ajoutera alors automatiquement les squelettes de vos méthodes dans la partie implémentation.
Inversement, si dans la partie implémentation de votre unité vous ajoutez un code de ce genre :

 
Sélectionnez

procedure TMaClasse.MaProcedure(param: integer);
begin
//Code
end;

En replaçant votre curseur dans la déclaration de TMaClasse et en utilisant Ctrl+Shift+C, Delphi ajoutera automatiquement la déclaration de MaProcedure dans la partie private de TMaClasse.
Vous pouvez ainsi déclarer ou implémenter autant de méthodes que vous le souhaitez, et mettre à jour l'ensemble du code d'une seule pression de trois touches !

Mais ce raccourci va encore un peu plus loin, avec la déclaration de propriétés dans une classe.
Imaginons que vous ajoutiez deux propriétés à votre classe TMaClasse, donnant ce code :

 
Sélectionnez

...
interface
...
type
  TMaClasse = class
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
    property Nom: String read fNom write SetNom;
    property Objets[Index: Integer]: TObject read GetObjet write SetObjet;
  end;
  
...

implementation

end.

A ce stade, en utilisant Ctrl+Shift+C (toujours en laissant le curseur dans la déclaration de TMaClasse) Delphi saura tout seul ajouter les déclarations et le code nécessaires. La présence du "f" devant "Nom" lui indique, bien que ce ne soit pas une norme du langage, qu'il doit déclarer une variable privée ; pour les autres identificateurs il crée les fonctions/procédures qu'il faut, et cela abouti au code suivant :

 
Sélectionnez

...
interface
...
type
  TMaClasse = class
  private
    { Déclarations privées }
    fNom: String;
    procedure SetNom(const Value: String);
    function GetNom(Index: Integer): TObject;
    procedure SetObjet(Index: Integer; const Value: TObject);
  public
    { Déclarations publiques }
    property Nom: String read fNom write SetNom;
    property Objets[Index: Integer]: TObject read GetObjet write SetObjet;
  end;
  
...

implementation

{ TMaClasse }

function TMaClasse.GetNom(Index: Integer): TObject;
begin

end;

procedure TMaClasse.SetNom(const Value: String);
begin

end;

procedure TMaClasse.SetObjet(Index: Integer; const Value: TObject);
begin

end;

end.

Lorsque vous développez des composants par exemple, utiliser ce raccourci constitue donc un gain de temps considérable. Si vous utilisez ce raccourci avec des méthodes surchargées, Delphi ajoutera automatiquement inherited dans l'implémentation de celles-ci, ou override dans sa déclaration (tout dépend si vous complétez la déclaration ou l'implémentation).

Cette complétion automatique des propriétés peut être désactivée dans les Options d'environnement en décochant la case "Finir les propriétés incomplètes" dans l'onglet "Explorateur".

Ctrl+J
Utilisé sur le mot adéquat, ce raccourci remplace le mot en question par la portion de code qui lui correspond, grâce aux modèles de code. Le "mot adéquat" est un raccourci qui se définit dans les options de l'éditeur, comme ce sera expliqué plus tard...

Ctrl+K+I et Ctrl+K+U
Ces deux raccourcis permettent d'indenter ou de désindenter un bloc de code sélectionné dans l'éditeur.
Par défaut, l'indentation est de deux caractères. Cette valeur peut-être changée dans les options de l'éditeur, dans l'onglet "Options du source".

III-1-b. Les modèles de code

Comme expliqué ci-dessus, Ctrl+J permet de transformer une raccourci en une portion de code qui lui correspond grâce aux modèles de code. Voici comment configurer ces derniers :

  • Delphi 5 et 6 : Ouvrez "Outils | Options de l'éditeur", et allez dans l'onglet "Audit de code"
  • Delphi 7 : Ouvrez "Outils | Options de l'éditeur", allez dans l'onglet "Options du source" et cliquez sur le bouton "Modifier modèles de code..."
  • Delphi 2005 : Ouvrez "Outils | Options...", sélectionnez l'item "Options du source" dans la branche "Options de l'éditeur" et cliquez sur le bouton "Modifier modèles de code..."
Fenêtre 'Modèles de code' de Delphi 5 et 6
Fenêtre 'Modèles de code' de Delphi 5 et 6
Fenêtre 'Modèles de code' de Delphi 7, 8 et 2005
Fenêtre 'Modèles de code' de Delphi 7, 8 et 2005

Le principe est simple : dans la vue "Modèles" sont listés les raccourcis disponibles et leur description. En cliquant sur l'un d'entre eux, vous faites apparaître dans la vue "Code" les lignes de codes qui le remplaceront.
L'ajout et la modification d'un modèle se font avec la même fenêtre, où vous entrez le raccourci à enregistrer et sa description :

Ajout/Modification d'un modèle de code
Ajout/Modification d'un modèle de code

Une fois que vous avez validé cette fenêtre, le nouvel item apparaît dans la liste des modèles (ou alors l'item existant est modifié) et vous pouvez éditer le code qui lui correspond.
Vous pouvez par exemple ajouter le raccourci "msg" avec pour description "Affichage d'un message", et entrer comme code "ShowMessage(|);". Le caractère "|" indique où doit se situer le curseur de saisie une fois le raccourci remplacé dans le code.

III-2. Navigation dans le code

III-2-a. Raccourcis clavier

Ctrl+F12
Ce raccourci affiche les unités du projet en cours et vous permet d'afficher celles que vous souhaitez éditer.

Ctrl+Tab
Si plusieurs unités sont en cours d'édition, ce raccourci active l'unité suivante en suivant l'ordre des onglets.
Si vous éditez la dernière unité ouverte, cela boucle sur la première. Ctrl+Shift+Tab
Si plusieurs unités sont en cours d'édition, ce raccourci active l'unité précédente en suivant l'ordre des onglets.
Si vous éditez la première unité ouverte, cela boucle sur la dernière.

Ctrl+Shift+X
Bascule le signet X sur la ligne en cours, où X est un nombre de 0 à 9.
A une même ligne peuvent être affectés plusieurs signets

Ctrl+X
Emmène au signet X, qui peut prendre la valeur de 0 à 9.

Ctrl+Shift+Flèche Haut ou Bas
Il y a deux cas à distinguer avec ce raccourci :
Soit vous êtes dans l'implémentation d'une routine, et dans ce cas vous êtes emmené à la ligne de déclaration de cette routine, soit vous êtes sur la ligne de déclaration d'une routine, auquel cas vous êtes emmené dans l'implémentation de celle-ci.

Ctrl+Click
Un click effectué sur un identificateur (nom de variable, de classe, etc.) en maintenant la touche Ctrl enfoncée vous mènera à la déclaration de cet élément.
Si vous cliquez sur le nom d'une unité dans une clause uses, Delphi tentera d'ouvrir le fichier cliqué.
Si vous utilisez cette fonctionnalité durant un débogage, Delphi ouvrira l'inspecteur de débogage sur l'identifiant cliqué.

Alt+Flèches Gauche ou Droite
Permet de parcourir les dernières positions du curseur dans les unités qui ont été ouvertes.
Au besoin, Delphi réouvrira une unité qui aurait été fermée entre temps.

III-2-b. L'explorateur de code

L'explorateur de code, fenêtre souvent ancrée sur la gauche de l'éditeur, présente une arborescence qui classe les différents éléments déclarés dans l'unité en cours. Apparaissent les classes qui y sont déclarées et leurs propriétés, leurs méthodes publiques, privées, protégées etc.
On y trouve également la liste des unités référencées dans la clause uses et les variables/constantes globales de l'unité.

Voici une copie d'écran de cet explorateur de code avec une unité contenant la déclaration d'une TForm Form1 qui possède une procédure privée, une fonction protégée et un TButton auquel a été assigné l'événement OnClick :

Explorateur de code
Explorateur de code

Vous remarquerez que chaque item reçoit une icône particulière en fonction de son type : une flèche verte pour les procédures, une jaune pour les fonctions, un cube pour les variables/constantes, une "boite" pour les unités référencées et enfin l'icône par défaut des nouveaux composants de Delphi pour les classes et les propriétés (les interfaces ont une icone similaire).

Un click sur l'un des items emmène soit à la déclaration de l'élément s'il s'agit d'une classe, d'une variable, d'une propriété (...), soit à son implémentation s'il s'agit d'une procédure ou d'une fonction.

Vous avez la possibilité, en sélectionnant un élément et en appuyant sur la touche F2, de renommer un élément. Une fois validée par Entrée, la modification est apportée au code.

Attention, il ne s'agit en aucun cas d'une fonctionnalité de refactoring !
Si vous modifiez le nom d'une procédure ou d'une fonction, son nom sera mis à jour autant dans la partie interface qu'implementation, mais qu'au niveau des déclarations. De même si vous modifiez le nom d'une variable, seule sa déclaration est changée.
En aucun cas l'ancien nom sera modifié dans le code en lui-même. Attendez-vous donc à des erreurs de compilation si vous changez le nom d'identificateurs de cette manière.

L'explorateur de code est paramétrable dans les Options d'Environnement (menu "Outils", onglet "Explorateur") :

Options de l'explorateur de code
Options de l'explorateur de code

Catégories de l'explorateur
Chaque catégorie cochée dans la liste de droite implique la création d'un "dossier" pour celle-ci dans l'arborescence de l'explorateur. C'est pourquoi par défaut les classes sont visibles directement en tête de liste et au premier niveau de l'arborescence, la case "Classes" n'étant pas cochée.
A côté de chaque case à cocher se trouve une petite icône, cliquable et à deux états : Image non disponible et Image non disponible.
Ces deux états indiquent si par défaut la catégorie concernée sera (respectivement) fermée ou développée dans l'explorateur de code.
Si vous voulez suivre correctement certaines catégories, il est conseillé de les développer par défaut, car tout modification du code provoque une mise à jour de l'arborescence, ce qui a pour effet de réinitialiser l'état de chaque catégorie.

Options de l'explorateur
L'option "Afficher l'Explorateur" se passe de commentaire. L'activation de "Surligner les éléments de classes incomplètes" permet d'afficher en gras les éléments qui seraient mal déclarés, ou déclarés de manière incomplète.
L'option "Afficher la syntaxe de la déclaration" n'est pas cochée par défaut mais peut s'avérer être utile une fois activée : elle permet d'afficher dans l'arborescence le types de variables, l'ancêtre des classes, les paramètres des méthodes etc.

Voici une copie d'écran de l'explorateur de code avec cette option activée :

Explorateur de code avec l'option 'Afficher la syntawe de la déclaration' activée
Explorateur de code avec l'option 'Afficher la syntaxe de la déclaration' activée

Tri Explorateur
Le choix de l'une de ces deux options triera les éléments de l'arborescence soit par ordre alphabétique, soit en fonction de l'ordre de déclaration des différents éléments dans le code source.

Options d'achèvement de classe
La seule option disponible ici active ou désactive la complétion automatique des propriétés "incomplètes". Plus clairement, si cette option n'est pas cochée, l'utilisation du raccourci Ctrl+Shift+C agira uniquement sur les méthodes et ne permettra pas la déclaration automatique des variables privées/méthodes nécessaires au fonctionnement des propriétés.

Les deux derniers jeux d'options s'appliquent à l'explorateur de projet, et ne seront pas décrites ici.

Si l'explorateur de code n'est pas affiché dans l'éditeur, vous pouvez l'activer grâce au raccourci Ctrl+Shift+E ou en cliquant droit sur l'onglet de votre unité et en choisissant l'item "Voir l'explorateur".

III-3. Sélection/Recherche dans le code

III-3-a. Raccourcis clavier

Shift+Alt+Flèches Directionnelles/Origine/Fin...
L'utilisation de ces combinaisons de touches permet de sélectionner du code par colonnes au lieu de sélectionner par lignes.
Les touches Origine, Fin etc. ont le même comportement qu'avec une sélection "normale".

Qu'entend-on par "sélection par colonnes" ?
Voici une copie d'écran qui vous éclairera :

Sélection par colonnes
Sélection par colonnes

Pour effectuer une telle sélection il suffit de positioner le curseur de saisie à gauche de "Elem1" puis, en maintenant les touches Shift et Alt enfoncées, de le descendre à droite de "f".

Les opérations de copier/coller sont bien sûr possibles. Attention toutefois, du texte copié avec une sélection par colonnes sera collé sur les lignes existantes, remplaçant éventuellement du code plutôt que d'être inséré à la position du curseur.

La sélection par colonnes est également possible à la souris, en maintenant Alt enfoncée.

En utilisant ce raccourci ou la sélection par colonnes à la souris, il arrive que l'état des touches Shift et Alt soit mal réinitialisé et vous ne pouvez alors plus que sélectionner par colonnes.
Dans ce cas, enfoncez simultanément les touches Ctrl, Alt et Shift et relâchez les pour remettre leur état à zéro.

Ctrl+F
Ce raccourci, bien connu, ouvre la boîte de dialogue "Rechercher". Outre une liste des dernières recherches effectuées, cette boîte de dialogue propose plusieurs options comme la sensibilité à la casse, la recherche de mots entiers uniquement, la direction de la recherche, sa portée (sélection ou globale) et son origine (début du document ou curseur).
Il est également possible de rechercher au moyen d'expressions régulières. Reportez-vous à l'aide pour plus de détails sur cette option.

Un onglet "Chercher dans les fichiers" propose de rechercher du texte dans plusieurs fichiers à la fois, en laissant le choix de choisir si la recherche doit se faire dans les fichiers du projet, dans ceux ouverts ou dans un répertoire particulier.

Ctrl+R
Ce dialogue est identique à la recherche, si ce n'est qu'il propose un champ de plus pour spécifier par quoi remplacer le texte à rechercher.
Une option permet de demander une confirmation avant d'effectuer chaque remplacement. Elle annule l'effet du bouton "Tout remplacer" et il faudra donc cliquer sur "Tous" dans le premier message de confirmation pour tout remplacer d'un seul coup.

F3
Cette touche va de paire avec Ctrl+F. Une fois une première occurence trouvée dans le code grâce à la recherche, un appui sur F3 relancera tout simplement la recherche pour trouver l'occurrence suivante.
Notez que le raccourci Ctrl+L a le même effet.

Ctrl+E
Ce raccourci est à utiliser n'importe où dans le code, pour y effectuer une recherche incrémentale en partant de la position du curseur. Cette recherche n'est pas sensible à la casse.
L'utilisation est la suivante : après avoir activé la recherche incrémentale, commencez à taper le mot que vous recherchez. Il s'affiche dans la barre de status et au fur et à mesure que vous tapez, Delphi sélectionne la première occurrence du mot à partir de la position initiale du curseur.

Voyons un exemple avec ce morceau de code :

 
Sélectionnez

type
  TForm2 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  public
    property blabla: string read fblabla;
  end;	

Supposons que le curseur de saisie soit placé juste avant "Button1". Après avoir pressé Ctrl+E, tapez "b", ce qui a pour effet de sélectionner le "B" de "Button1".
Ajoutez un "l", et la sélection est maintenant sur le "bl" de "public".
Enfin ajoutez "abla" et vous verrez que lettre par lettre, "blabla" sera sélectionné. A ce stade, vous souhaiterez éventuellement trouver l'occurrence suivante de "blabla", ce qui est possible grâce au raccourci F3.
Si vous souhaitez élargir votre recherche en effaçant une partie du mot, utilisez tout simplement la touche Retour Arrière. La sélection reculera éventuellement, sur la première occurence (en partant de la position initiale du curseur) du mot ainsi modifié.

III-3-b. Recherche / Remplacement au moyen d'expressions régulières

Une recherche "classique", en entrant un simple mot, c'est bien. Mais parfois, ce n'est pas suffisant. Les expressions régulières offrent une flexibilité sans égale aux fonctions de recherche et de remplacement, en permettant des recherches "génériques", la réutilisation des résultats de recherche etc. Ce paragraphe n'a pas pour vocation de vous enseigner toute la théorie sur les expressions régulières, mais seulement d'en donner quelques bases et leur application à la recherche et au remplacement de texte dans Delphi.

Une expression régulière est une chaîne de caractères particuliers formant un motif. Cette expression permet d'effectuer une recherche générique afin de retrouver tout mot ou groupe de mots répondant à ce motif.
Par exemple, on peut imaginer un motif qui soit destiné à rechercher tous les mots commençant par un 'B' et se terminant par un chiffre. Ce motif permettra de retrouver dans votre code tous les 'Button1', 'Button2' etc.

Delphi utilise ses propres caractères pour définir un motif, mais ils ne diffèrent pas trop des plus connus (POSIX et PERL par exemple).
La liste de ces caractères (présente dans l'aide en ligne) est la suivante :

Caractère Description
^ Indique un début de ligne (à placer en début d'expression)
$ Indique une fin de ligne (à placer en fin d'expression)
. Représente un caractère, quel qu'il soit
* Quantificateur de répétition. Placé après un caractère, il signifie que ce caractère peut éventuellement être présent et répété (à l'infini). Exemple : "bo*" permet de trouver "b", "bo", "boo", "booo" etc.
+ Quantificateur de répétition. Placé après un caractère, il signifie que ce caractère sera présent au moins une fois. Exemple : "bo+" permet de trouver "bo", "boo", "booo" etc. mais pas "b"
[ ] Les crochets permettent de définir une classe de caractères. Une classe de caractères permet de rechercher uniquement l'un des caractères qu'elle contient. Par exemple, "[abc]" permet de chercher "a" ou "b" ou "c". Il n'y a pas de séparateur entre les caractères.
[^] Ajouté au début d'une classe de caractères, "^" permet de la complémenter. La classe sert alors à rechercher tous les caractères à l'exception de ceux qu'elle contient. Par exemple "[^abc]" trouvera tout caractère qui n'est pas "a", "b" ou "c".
[-] Dans une classe de caractères, le "-" permet de définir des plages de caractères. Par exemple, "[a-z]" permet de rechercher toutes les lettres minuscules de "a" à "z". "[a-zA-Z]" permet de chercher n'importe quelle lettre, minuscule comme majuscule.
{ } Les accolades permettent de créer des groupes dans le motif. Ces groupes, au nombre maximum de 10, seront utilisés pour les fonctionnalités de remplacement et détaillés ci-après.
\ L'antislash est le caractère d'échappement dans une expression. Il permet d'indiquer qu'un caractère ne doit pas être interprété dans le motif, mais pris littéralement. Par exemple, "[0-9]\.[0-9]" permet de trouver les nombres de la forme "x.x". Sans le "\" le point aurait été interprété comme "n'importe quel caractère" et le motif aurait retourné aussi bien "1.4" que "2k5" ou "3%6".

Les descriptions et les exemples fournis dans l'aide de Delphi ne reflètent pas le comportement des différents caractères lors d'une recherche. C'est pour cette raison qu'ils ont été modifiés dans cette liste.

Pour activer la recherche grâce aux expressions régulières, cochez la case "Expressions régulières" dans les options de la fenêtre "Rechercher". Ainsi le texte recherché sera interprété comme une expression régulière.
Pour construire une expression régulière, vous pouvez combiner les caractères présentés ci-dessus, avec éventuellement les caractères de votre choix, sans oublier d'utiliser le caractère d'échappement au besoin.

Voici quelques exemples de recherches que vous pouvez tester :

  • B[a-zA-Z]*[0-9]+ trouvera tous les mots commençant par un "B" et se terminant par un ou plusieurs chiffres ([0-9] avec le quantificateur +), avec entre les deux un nombre indéterminé de lettres ([a-zA-Z] avec le quantificateur *). Par exemple : "Button1", "Button2"...

  • procedure[^.]+; trouvera toutes les déclarations de procédures de votre unité. [^.]+ signifie "n'importe quel caractère autre que le point, répété indéfiniment". Notez que le point n'a pas besoin d'être échappé dans une classe de caractères.

  • ^.*procedure[^.;]+;$ est une variante de la précédente, elle trouvera la ligne contenant une déclaration de procédure sans convention supplémentaire (comme override, virtual etc.). Ceci grâce aux spécificateurs de début (^ suivi de .* pour prendre en compte l'indentation) et de fin ($) de ligne, et à l'ajout de ";" dans la classe de caractères pour que celui qui la suit désigne le seul point-virgule qui doive être présent.

  • NomDeMethode\([^,]*, *ValeurParam[^)]*\) permet de rechercher une méthode de nom "NomDeMethode", appelée avec la valeur ValeurParam en deuxième argument.

Le remplacement de texte se passe exactement de la même manière si ce n'est que vous avez la possibilité d'utiliser les groupes, mentionnés plus haut.
Un groupe se définit dans un motif grâce aux accolades. L'intérêt d'un groupe est d'être réutilisable dans la chaîne "Remplacer par". Chaque groupe de votre motif reçoit un nombre qui l'identifie, de 0 à 9, dans l'ordre d'apparition puis d'imbrication. Le groupe le plus interne est donc le groupe ayant l'identifiant le plus élevé.
Par exemple dans l'expression "{p{ro{ced}ur}e}", le groupe n°0 renvoie "procédure", le groupe n°1 renvoie "rocedur" et le groupe n°2 renvoie "ced".

Pour utiliser le contenu d'un groupe dans "Remplacer par", il faut y faire référence en donnant son identifiant précédé d'un antislash. Pour l'exemple, imaginons que vous souhaitiez remplacer tous les "procedure" de votre code par "procedureced". Il n'y a aucun intérêt à utiliser les expressions régulières dans ce cas précis, mais le résultat est aisé à comprendre :
Dans "Chercher" tapez "{pro{ced}ure}", et dans "Remplacer par" tapez "\0\1". "\0" Renvoyant au premier groupe et "\1" à celui imbriqué, cette opération remplacera effectivement les "procedure" par "procedureced".

Voici quelques exemples plus intéressants utilisant les groupes :

Chercher Remplacer par Description
procedure{.*}; function\0: integer; Transforme toutes les procédures en fonction renvoyant un integer. Le groupe porte ici sur le nom de la procédure et la liste de ses paramètres, pour les restituer à l'identique.
/\*{.*}\*/ \{\0\} Transforme un commentaire multilignes C++ ("/* ... */") en commentaire multilignes Delphi. Notez l'échappement des astérisques et des accolades.
//{.*}$ \{\0\} Transforme un caractère "//" en commentaire multilignes.
procedure {.*}; *var[^:]*: *{[^;)]*}{;*.*}\);( *{.*;})*$ function \0\2): \1; \3 Cette expression est un peu plus compliquée. Elle transformera toute procédure possédant au moins un paramètre var en fonction renvoyant le type de ce paramètre. S'il y a plusieurs paramètres var, c'est le dernier qui sera pris en compte.

Le premier groupe inclut le nom de la procédure et ses premiers paramètres. Vient ensuite "var" précédé éventuellement d'espace(s). [^:]* permet de passer le nom de la variable var et de s'arrêter aux premiers ":" rencontrés.
Le second groupe donne le type de la variable. Suivent ensuite d'éventuels paramètres, puis la fermeture de la parenthèse et le ";".
Les conventions, surcharges (...) constituent le dernier groupe. Comme elles sont optionnelles, elles sont entourées de parenthèses avec le quantificateur *

Pour exemple, "procedure Proc(A:integer; var B: String; C: Integer); override;" sera remplacé par "function Proc(A:integer; C: Integer): String; override;"

Vous remarquerez que les groupes sont utilisés pour récupérer une partie de texte susceptible de varier mais que l'on souhaite restituer telle quelle.

Il ne vous reste plus qu'à étudier ces quelques expressions et à en expérimenter de votre propre confection pour bien saisir leur utilité.

Delphi propose également d'utiliser la syntaxe BRIEF pour les expressions régulières. Référez-vous à l'aide en ligne pour plus de détails.

IV. Divers

IV-1. Raccourcis clavier

F12
Ce raccourci permet de passer de l'unité en cours d'édition à la fiche qui lui correspond, ou encore de la fenêtre de gestion d'un paquet à sa version texte.

Ctrl+Shift+G
Utilisé dans l'éditeur, ce raccourci y générera un GUID (Global Unique IDentifier), utilisable pour identifier une nouvelle interface que vous développez.

Alt+0 (zéro)
Ce raccourci appelle la Liste des fenêtres, qui permet d'obtenir un listing de toutes les fenêtres ouvertes, et d'ammener en avant-plan celles dont vous avez besoin.
Cela peut-être très pratique pour rendre visible la palette d'alignement qui aurait été recouverte par l'éditeur de code, par exemple.

Liste des fenêtres
Liste des fenêtres

Ctrl+O+O
Il arrive parfois que votre programme se compile et fonctionne très bien sur votre machine, mais pas sur celle des autres.
Cela est possible par exemple dans le cas où les options choisies dans Delphi sont différentes entre les deux PC utilisés. Pour remédier à ce problème, l'utilisation de Ctrl+O+O permet d'ajouter au début de l'unité en cours les directives de compilation qui correspondent aux options que vous avez sélectionnées pour votre projet.

Ctrl+K+W
Utilisez ce raccourci après avoir sélectionné un bloc de texte. Il vous permettra d'enregistrer ce bloc dans un fichier de votre choix.

Ctrl+K+R
Ce raccourci effectue l'opération inverse de Ctrl+K+W : placez votre curseur dans le code, et utilisez-le pour y insérer le contenu d'un fichier.

F1
Last but not least, le raccourci qu'il faut connaître et ne pas hésiter à utiliser abusivement : l'aide !
L'aide contextuelle est très bien développée dans Delphi. Ainsi en pressant F1 dans l'inspecteur d'objets vous obtiendrez de l'aide sur la propriété ou l'événement qui y est sélectionné. En l'utilisant lorsqu'une fiche est ouverte, c'est l'aide du composant actuellement sélectionné qui sera affiché. Quant au code, une simple pression sur F1 lorsque votre curseur est positionné sur un mot vous proposera les pages d'aide disponibles pour ce mot.
Si vous ne trouvez pas un terme dans l'index de l'aide, n'hésitez pas à le saisir dans votre code (peu importe où) et à faire F1 dessus, vous avez de grandes chances d'obtenir ce que vous voulez !

IV-2. Liste A faire (To Do List)

IV-2-a. Présentation générale

L'outil "Liste A faire" est un outil très abouti de Delphi, qui mérite d'être mis en avant. Il permet de gérer une liste de tâches qui restent à effectuer dans un projet.

Ces tâches peuvent être détaillées soit directement sous forme d'un commentaire respectant un formatage particulier dans le code de vos unités, soit dans un fichier NomProjet.todo géré automatiquement par Delphi à partir de la liste.

Dans la liste, les éléments sont distingués en trois groupes :

  • Les éléments du fichier .todo du projet
  • Les éléments des unités ouvertes dans l'éditeur
  • Les éléments des unités du projet, ouvertes ou non

En plus de cela, l'affichage des éléments varie selon le fichier où il se trouvent :

  • Si l'élément se trouve dans le code d'une unité ouverte dans l'éditeur ou dans le fichier .todo du projet, il apparaîtra sans style particulier.
  • Si l'élément se trouve dans l'unité actuellement en cours d'édition, il apparaîtra en gras.
  • Si l'élément se trouve dans une unité du projet qui n'est pas ouverte, il apparaîtra en grisé.

Et enfin, on trouve à côté de chaque élément de la liste une icône qui indique :

que l'élément est un commentaire dans une unité.

que l'élément est contenu dans le fichier .todo du projet.

que l'élément est contenu dans le fichier .dpr du projet

Afin de mieux visualiser ces différenciations, voici une copie d'écran montrant une liste d'éléments à faire placés à tous les endroits possibles :

Liste A faire
Liste A faire

IV-2-b. Propriétés d'un élément

En se référant à la copie d'écran précédente, on peut distinguer sept informations différentes pour un même élément :

  • Son état à faire ou effectué, représenté par la case à cocher. Si la case est cochée, la tâche est considérée comme effectuée et l'item est rayé dans la liste. Dans le code, "TODO" est remplacé par "DONE". Vous pouvez décider de ne pas afficher les éléments effectués en décochant "Afficher les éléments achevés" dans le menu contextuel
  • Son type, caractérisé par l'une des trois icônes citées auparavant et indiquant qu'il s'agit d'un commentaire dans une unité, dans le fichier .dpr ou dans le fichier .todo du projet.
  • L'action, la tâche à effectuer. Il s'agit d'une description aussi longue que vous le souhaitez pour indiquer ce qu'il y a à faire.
  • La priorité de la tâche (colonne "!"). Cette priorité prend une valeur de 1 à 5, la priorité la plus forte étant 1. Vous pouvez donner une priorité nulle à un élément, comme c'est le cas pour tous ceux de la copie d'écran.
  • Le module dans lequel se trouve l'élément. Cette colonne est renseignée automatiquement par Delphi, si l'élément se trouve dans un fichier .pas ou .dpr.
  • Le propriétaire de l'élément, c'est-à-dire la personne qui doit se charger d'accomplir la tâche ou qui a ajouté cette tâche à la liste.
  • La catégorie à laquelle appartient l'élément. Cette catégorie est totalement arbitraire et permet de mieux organiser les éléments s'ils sont nombreux.

Le propriétaire et la catégorie sont deux chaînes de caractères aussi longues que vous le souhaitez et qui peuvent contenir n'importe quel caractère, à l'exception du tiret ("-") et des deux points (":").

IV-2-c. Ajout, modification et suppression d'un élément

Comme dit plus haut, un élément peut-être ajouté soit dans le code, soit dans le fichier .todo du projet.

Le format des commentaires à inclure dans le code est le suivant :

Format d'un élément 'A faire'
Sélectionnez

{TODO [Priorité] [-oPropriétaire] [-cCatégorie] : Description}

Les éléments Priorité, Propriétaire et Catégorie sont facultatifs. Cette syntaxe est reconnue avec les trois types de commentaires disponibles dans Delphi.
Une fois que vous aurez entré votre commentaire, la liste sera automatiquement mise à jour.

Pour ajouter un élément dans le fichier .todo du projet, il faut agir directement au niveau de la liste : cliquez droit dans celle-ci et choisissez l'item "Ajouter".
La fenêtre suivante apparaît, et vous permet de choisir les différentes options de votre élément :

Ajout d'un élément à faire
Ajout d'un élément à faire

Si vous souhaitez modifier un élément existant, cliquez droit dessus et choisissez l'item "Modifier". La fenêtre de modification est identique à celle d'ajout, à ceci près qu'on y trouve en plus une case à cocher "Terminer" qui permet de passer l'élément en état "effectué".
Vous ne pouvez pas modifier un élément qui se trouve dans une unité non ouverte.

Pour supprimer un élément il suffit de le sélectionner et de presser Suppr, ou bien de choisir l'item "Supprimer" dans le menu contextuel.

Toute modification ou suppression est instantanément répercutée dans le code s'il s'agit d'un commentaire. Le fichier .todo est mis à jour à chaque enregistrement du projet.

IV-2-d. Les différentes opérations possibles

En plus des simples actions d'ajout, modification et suppression, quelques opérations sont disponibles.

La plus élémentaire est le double-click sur un élément. S'il s'agit d'un commentaire dans une unité, Delphi activera l'unité concernée (l'ouvrira auparavant si nécessaire) et vous ammènera directement au commentaire.
S'il s'agit d'un élément enregistré dans le fichier .todo, le double-click ouvre la fenêtre de modification de l'élément.

Les autres opérations sont accessibles à partir du menu contextuel.
Vous pouvez trier vos éléments selon chacune des propriétés de ceux-ci, par ordre alphabétique ou numérique croissant ou décroissant, ou suivant leur état, sachant que les éléments effectués seront renvoyés en fin de liste.

Vous pouvez également filtrer la liste afin de n'afficher que certains éléments. Le filtrage porte sur les catégories, les propriétaires ou les types de vos éléments.
A partir du menu contextuel vous accédez à une liste de case à cocher qui vous permet de choisir quels éléments afficher en fonction des valeurs de ces trois critères.

La dernière fonctionnalité est la possibilité de copier la liste des éléments soit sous forme de texte brut, soit sous forme d'un tableau HTML, grâce au sous-menu "Copier en" du menu contextuel.
De nombreuses propriétés du tableau HTML sont personnalisables en choisissant "Propriétés de table..." dans le menu contextuel.

Conclusion

Ce récapitulatif est maintenant terminé. J'espère que vous avez pu y trouver de nouveaux raccourcis ou des outils qui faciliteront vos développements futurs.
Notez bien que certains raccourcis risquent de ne pas fonctionner avec votre version de Delphi, ou en fonction de la configuration que vous aurez éventuellement choisie.
Tout particulièrement, la version personnelle de Delphi 2005 ne comporte pas un grand nombre de raccourcis comme Ctrl+Shift+C, Ctrl+Shift+Flèche Haut/Bas...

Si vous voulez une liste complète des raccourcis disponibles en fonction des différentes configuration clavier, référez-vous à l'aide de Delphi.

Contributions

Les raccourcis mentionnés ici on été résumés dans un tableau Excel, disponible en téléchargement :
Miroir 1
Miroir 2 (Si le Miroir 1 ne fonctionne pas)

D'autres raccourcis ont été ajoutés. Le tout tient en impression sur deux pages, pour une référence rapide.
Merci à fabzouni pour cette contribution !

Remerciements

Merci à Delphiprog, Laurent Dardenne, Nono40 et sjrd pour leurs suggestions et leurs commentaires.