Vous l'avez peut-être appris au détour d'un message sur les forums de developpez.com ou sur le site Borland, la prochaine version de Delphi est actuellement en phase de beta-test.
Les dates de sortie ne sont pas encore connues et le nom officiel n'a pas été choisi mais il y a de fortes chances qu'il fasse partie des propositions suivantes : Delphi 9, Delphi 2005 ou Borland Developper Studio. Personnellement, je ne serais pas étonné que ce soit ce dernier qui remporte le plus de suffrages dans la mesure où il exprime bien ce qu'est et ce que sera ce nouvel environnement de développement.
Pour l'instant, nous nous contenterons d'utiliser son nom de code Diamondback tout au long de cet article.

Developpez.com a décidé de vous informer le plus tôt possible de ce que sera votre futur outil de développement. Cet article est donc basé sur une pré-version du produit final. Celle-ci intègre la plupart des fonctionnalités qui seront présentes dans la version finale, mais vous ne devez pas perdre de vue qu'il y aura certainement de nombreuses modifications apportées avant la sortie officielle de Diamondback. Certaines possibilités seront certainement ajoutées ou améliorées et certaines disparaîtront peut être de la version officielle. Seul le temps nous dira ce qu'il en est exactement.
Cela ne doit toutefois pas nous empêcher de faire un tour d'horizon de ce nouveau produit, qui je dois l'avouer, est très excitant et novateur. Nous nous contenterons, pour cette première approche des éléments les plus attendus par la communauté des développeurs Delphi : l'EDI et l'éditeur de code.
Commençons tout de suite par ce qui est certainement l'aspect le plus étonnant et le plus ambitieux de Diamondback.

Ce n'est pas une nouveauté pour certains mais cela risque de faire l'effet d'un pavé dans la mare pour de nombreux autres : Diamondback est un outil de développement RAD multi langage. Oui, vous avez bien lu. L'époque où chaque langage avait son propre EDI (Environnement de Développement Intégré) est désormais révolue. Diamondback inaugure une nouvelle façon de travailler et le fait de bien belle manière. En effet, il vous sera possible de développer en Delphi Win32, Delphi .NET et C# dans le même EDI. Vous pourrez même utiliser des projets de types différents dans un même groupe de projet.

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 :

Le code source de la fenêtre juste après la création.

Le code source de la fenêtre après l'ajout du gestionnaire d'événement OnClick.

Le code source de la fenêtre après l'ajout du test.

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.

Ici les fenêtres sont "embarquées".

Alors que là elles sont flottantes.

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.

J'espère que ce rapide tour d'horizon des nouvelles fonctionnalités de l'interface de Diamondback vous aura donné comme moi l'envie d'en savoir plus sur notre prochain outil de développement.
Nous aurons l'occasion d'en reparler au fur et à mesure de l'avancement de son développement et jusqu'à sa sortie.