Premier contact avec le futur de Delphi

Comme nous venons de le voir, le nouvel IDE de Diamondback permet de développer en Delphi pour Win32 (l'équivalent de Delphi 7 et de ses prédécesseurs), en Delphi pour .NET (comme Delphi 8) et en C#. Un icône présent dans la barre d'outils permet de savoir à tout moment dans quel environnement le développeur se trouve : pour Delphi pour .NET, pour Delphi pour Win32 et pour C#.

La modification et l'enregistrement des fichiers dans l'EDI créé de multiples versions de sauvegarde dans le répertoire caché _history du répertoire courant. Des options permettent de contrôler les différents paramètres de ces sauvegardes.

La nouvelle vue Historique permet de voir et de comparer différentes versions d'un fichier, qu'il s'agisse de plusieurs versions de sauvegarde, de la dernière version enregistrée ou même d'une version actuellement en cours de modification dans l'éditeur. Il est possible de revenir à n'importe quelle version antérieure et de parcourir les fichiers grâce à un mécanisme de défilement synchronisé.
Etudions un petit exemple simple : imaginons que nous avons créé une nouvelle fenêtre. Nous y avons ajouté un bouton et utilisé l'événement OnClick pour afficher un message. Nous avons décidé ensuite de n'afficher ce message que si une condition est remplie. Dans notre exemple, le fichier est passé par 3 états distincts. La création initiale de la fenêtre, l'affichage du message et l'ajout de la condition. Si nous explorons l'historique, nous voyons clairement ces trois étapes :

Nous pouvons également comparer ces différentes versions et voir ce qui a été modifié grâce à la présence de marques dans la marge :

Ici, nous comparons la version actuelle (avec test) à la version n-1 (sans test). Les signes + et - nous indiquent les modifications apportées au source.

La vue Structure permet de voir la hiérarchie du code source ou du code HTML présent dans l'éditeur ou des composants utilisés dans une fenêtre au design. Un double clic sur un des éléments du source positionne automatiquement l'éditeur sur sa déclaration ou son emplacement dans l'éditeur de code ou sélectionne automatiquement le composant en question dans l'éditeur de fenêtre.

Si le code source présente des erreurs de syntaxe, elles apparaissent également dans la vue Structure :

Un nouvel assistant permet d'importer des composants VCL, ActiveX ou .NET dans un package.

Une option vous permet de choisir si vous désirez que les fenêtres soient incluses dans la fenêtre principale de l'EDI ou qu'elles soient flottantes (comme sous Delphi 7). Ainsi, chacun peut adapter l'environnement de développement à son habitude de travail.

La nouvelle palette de composants ayant remplacé celle que nous avons connu dans les versions 1 à 7 de Delphi permet de faciliter la recherche de composants dans de nombreuses catégories. La boîte de recherche a été remplacée par un bouton de filtrage très pratique. Il suffit de cliquer dessus et de taper les premières lettres du nom du composant recherché pour avoir accès à une liste filtrée.

La palette de composant après avoir tapé la lettre 'b'. Seuls les composants dont le nom commence par cette lettre apparaissent. Les catégories sont symbolisées par les noms en gras. Le menu déroulant Catégories permet également d'aller directement à une catégorie spécifique sans avoir à faire défiler l'ensemble de celles disponibles.

Sous ce nom barbare se cachent des fonctionnalités extrêmement pratiques et améliorant énormément la productivité du développeur. Il est ainsi possible de restructurer et de modifier un code source tout en maintenant son comportement. Les outils de refactoring présents dans Diamonback incluent l'extraction de code, le changement de nom de symboles, la déclaration automatique de variables et d'attributs, la recherche d'unités et d'espaces de nom et plus encore.
Attardons nous quelques instants sur certaines de ces possibilités.
L'extraction de code permet de prendre une partie de code que l'on désire réutiliser et de la transformer en procédure ou fonction de manière totalement automatique.
Imaginons que nous ayons un code source de ce type :

procedure TForm2.Button1Click(Sender: TObject);
var
  i: Integer;
begin
  button1.Caption:= 'Modification en cours';
  for i:= 0 to ListBox1.Items.Count - 1 do
    ListBox1.Items[i]:= ListBox1.Items[i] + ' modifié';
  button1.Caption:= 'Modification terminée';
end;

Pour notre exemple, cette procédure affectée à l'événement OnClick d'un bouton se contente de modifier les lignes d'un TListBox. En cours de développement, nous nous rendons compte que nous allons devoir réécrire plusieurs fois ce code pour l'utiliser avec plusieurs boutons ou autres composants. Il suffit de sélectionner la partie de code à extraire et de choisir l'outil Extract method dans le menu Refactoring.

Diamondback génère automatiquement une nouvelle méthode qu'il propose dans une fenêtre permettant de juger du résultat avant de valider l'opération.

Nous pouvons voir que l'opération a bien extrait nos deux lignes de code et ajouté la déclaration de la méthode ainsi que celle de la variable de boucle.
Cet exemple bien pauvre ne dévoile qu'une infime partie de ce que cet outil est capable de faire.

Un autre des outils de refactoring nous permet de ne plus nous soucier de la déclaration des variables utilisées dans notre code source. Si nous reprenons notre exemple précédent en enlevant la déclaration de la variable i. L'éditeur va nous signaler que cette variable n'est pas déclarée. Il est possible de le faire automatiquement en utilisant l'outil approprié.

Comme pour la fonction d'extraction de code, une fenêtre intermédiaire permet de modifier certaines options avant de valider l'opération.

Une fois le bouton Ok cliqué, la variable i est automatiquement ajoutée dans la section var de la méthode. Il est même possible de demander l'initialisation de la variable en début de code.
Si nous cochons l'option SetValue et cliquons sur Ok, nous obtenons le code suivant (même si l'initialisation de la variable i n'a pas de sens dans cet exemple) :

procedure TForm2.Button1Click(Sender: TObject);
var
  i: Integer;
begin
  i := 0;
  button1.Caption:= 'Modification en cours';
  for i:= 0 to ListBox1.Items.Count - 1 do
    ListBox1.Items[i]:= ListBox1.Items[i] + ' modifié';
  button1.Caption:= 'Modification terminée';
end;

Il est ainsi possible de déclarer automatiquement un attribut de classe de la même façon, de renommer une variable ou un attribut dans tout code source en étant certain de ne pas se tromper et sans utiliser la fonction de remplacement, souvent source d'erreurs. Il est enfin possible d'extraire des chaînes de caractères pour les transformer en resourcestring de façon totalement automatique.
Ce survol rapide et très incomplet devrait vous permettre d'imaginer l'extrême intérêt de ces fonctionnalités qui font gagner énormément de temps en se chargeant de ces opérations qui ne sont généralement pas passionnantes mais pourtant obligatoires.

Cette fonctionnalité qui se rapproche également du refactoring permet de modifier le nom d'un identificateur dans l'ensemble du code sélectionné. Il suffit de sélectionner la partie du code source qui doit être affectée et de cliquer sur le bouton Sync Edit apparaîssant dans la marge. Le curseur se positionne automatiquement sur le premier identificateur. En tapant son nouveau nom, nous voyons l'ensemble du code source sélectionné être modifié pour s'adapter au nouveau nom.

Comme nous l'avons déjà vu précédemment, les erreurs de syntaxe sont symbolisées par un soulignement en rouge directement dans le code source. Cela permet de les repérer instantanément sans avoir même besoin de compiler le code.

Les versions récentes de Delphi nous ont habitué à la possibilité d'obtenir des informations sur un identificateur en passant le curseur de la souris sur celui-ci. Cette fonctionnalité a été étendue en affichant une fenêtre d'information contenant des liens vers des informations supplémentaires lorsqu'elles sont disponibles.

Il est désormais possible de commenter et décommenter automatiquement une ligne ou toute une sélection en utilisant la combinaison de touches Ctrl + / Il n'est ainsi plus nécessaire d'avoir recours à un expert pour réaliser cette opération si simple mais si utile.