Raccourcis et Outils de l'IDE

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 :

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 :

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

implémentation

end.

À 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 aboutit au code suivant :

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

implémentation

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

Comme expliqué ci-dessus, Ctrl+J permet de transformer un 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… »

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 :

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.

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.
À 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+Clic
Un clic 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.

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 :

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 « boîte » 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 icône similaire).

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

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

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.
À côté de chaque case à cocher se trouve une petite icône, cliquable et à deux états : et .
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 toute 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 type 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 :

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

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 :

Pour effectuer une telle sélection, il suffit de positionner 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.

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 pair avec Ctrl+F. Une fois une première occurrence 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 statut 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 :

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é. À 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 occurrence (en partant de la position initiale du curseur) du mot ainsi modifié.

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 :

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 :

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

L'outil « Liste À 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ù ils 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é 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 :

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

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 (« : »).

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 :

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

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.

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

La plus élémentaire est le double-clic 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 amènera directement au commentaire.
S'il s'agit d'un élément enregistré dans le fichier .todo, le double-clic 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.
À partir du menu contextuel vous accédez à une liste de cases à 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.