Créer une fenêtre « Assistant » (ou « Wizard »)

Un assistant est une fenêtre composée de plusieurs écrans qui s'enchainent en cliquant sur des boutons « Précédent » et « Suivant ». Généralement, il y a également un bouton « Terminer » qui amène directement au dernier écran et valide la fenêtre.

Il n'est pas très facile de faire une fenêtre composée de plusieurs fenêtres, à part avec un TPageControl (onglets), mais ça ne répond pas tout à fait au besoin : dans un assistant, on souhaite contrôler l'enchainement des écrans, éventuellement en sauter certains (en fonction des choix de l'utilisateur) et valider chaque écran avant de passer au suivant. Tout ceci n'est pas possible avec un TPageControl, à moins de bricoler avec ses événements et ceux de ses TTabSheet.

La solution proposée ici est basée sur une fenêtre (TDlgAssistant) qui manipule une liste de frames. La fenêtre comporte les boutons de navigation et chaque frame représente un écran de l'assistant. Les frames devront répondre à un certain nombre de contraintes (validation de la saisie, présence ou non des boutons « précédent » et « terminer », frame suivante à afficher…), nous allons donc créer une frame qui servira de classe de base à toutes les frames de l'écran et qu'on appellera TFrameBaseAssistant.

Ensuite, pour chaque fenêtre assistant que nous devrons créer, il suffira simplement de créer les frames basées sur TFrameBaseAssistant et d'en passer la liste à TDlgAssistant.

Une frame (ou un cadre si votre Delphi parle français) est un conteneur de composants, c'est-à-dire qu'elle peut contenir d'autres composants, y compris d'autres frames. La frame ressemble à la form (fiche ou fenêtre) dans sa façon de gérer et détenir les composants, en revanche elle n'a pas le comportement d'une fenêtre : elle n'a pas de bordure, on ne peut pas l'afficher par une méthode « Show » et elle n'a pas de menu. C'est juste un « intérieur de fenêtre ».

L'utilisation des frames permet d'obtenir une interface plus souple, car les frames peuvent être mises n'importe où, dans des fenêtres évidemment, mais aussi dans des onglets ou bien dans d'autres frames. Par exemple, on peut passer très facilement d'un affichage par onglets à un affichage en fenêtres MDI en changeant simplement la propriété Parent de la frame. Ça facilite la séparation entre la logique des écrans et la logique d'enchainement des écrans.

Lorsque l'on conçoit une application, on a tendance à créer tous les écrans dans des TForm. Idéalement, il faudrait créer uniquement des frames et n'utiliser les forms que comme un moyen de visualiser les frames.

Par exemple, si votre application contient un écran avec un DBGrid et des boutons « ajouter », « modifier », « supprimer » (écran très classique), le fait de concevoir cet écran dans une frame vous permet de l'utiliser :

• simplement dans une fenêtre, afin de visualiser une table ;
• dans la « fiche détail » d'un enregistrement, afin de visualiser une relation maître/détail

Pour terminer sur les frames, voici un exemple de code qui affiche une frame dans une fenêtre.

interface
  TFrame2 = class(TFrame)
    Label1: TLabel;
    MainMenu1: TMainMenu;
    Fichier1: TMenuItem;
    Fermer1: TMenuItem;
  public
    procedure AfficheToi;
  end;

implementation  

procedure TFrame2.AfficheToi;
var
  f : TForm;
begin
  // On crée une fenêtre vide dans laquelle on va mettre la frame (self) le temps de l'affichage
  f := TForm.Create(nil);
  with f do
  try
    caption := self.Caption;
    Menu := MainMenu1;
    clientWidth := self.Width;
    clientHeight := self.Height;
    self.Top := 0;
    self.Height := 0;
    self.Parent := f;
    self.Align := alClient;
    Position := poScreenCenter;
    showModal;
    self.Parent := nil;
  finally
    f.Free;
  end;
end;

Pour aller plus loin avec les frames, je vous invite à regarder le code fourni avec cet article et à utiliser la touche F1 sur TFrame dans Delphi, l'aide est très fournie sur ce sujet. Notamment, comment enregistrer une frame dans la palette de composants et l'ajouter au référentiel d'objets.

L'exemple fourni avec mon article Exécuter une requête dans un thread est également à base de frame, mais avec un TPageControl.

La création d'un assistant consiste à créer les frames qui le composent en les faisant hériter de TFrameBaseAssistant. En fonction des besoins, il faudra redéfinir certaines méthodes de cette classe.

Les deux méthodes importantes sont validationFiche et beforeNext, et il n'est pas forcément facile de savoir où mettre quoi.

• Dans validationFiche :

  • on vérifie que les zones ont été correctement saisies

    • si la frame ne peut être validée, on déclenche une EValidationFrameException, par exemple : raise EValidationFrameException.Create('La zone nom est obligatoire',editNom), (le focus sera donné au contrôle editNom) ;
  • et c'est tout !

• Dans beforeNext :

  • si l'assistant sert à modifier un objet, on transfère les zones de l'écran dans les zones de l'objet ;

  • si la frame suivante n'est pas celle qui suit immédiatement dans la liste, on l'indique à ce niveau :

    • si on connait le nom de la frame suivante, on renseigne le paramètre nextFrameName,
    • si on connait la classe de la frame suivante, on renseigne le paramètre nextFrameClass.

IV-A. Afficher l'assistant▲

       function TFormMain.assistant(f: TMonFichier): integer;
       var
         tmp : TMonFichier;     
       begin
         tmp := TMonFichier.Create;
         try
{ 01 }     with TDlgAssistant.Create(nil) do
           try
{ 02 }       Caption := 'Assistant fichier';
{ 03 }       tmp.copyFrom(f);
{ 04 }       ajouterObjet('fichier', tmp, false);
{ 05 }       ajouterFrame(TFrameWizFichierNomType.Create(nil));
{ 06 }       ajouterFrame(TFrameWizFichierContenu.Create(nil));
{ 07 }       ajouterFrame(TFrameWizFichierOptionTxt.Create(nil,[aoComeback, aoIsLast, aoGotoEnd]),'optionstxt');
{ 08 }       ajouterFrame(TFrameWizFichierOptionHTML.Create(nil),'optionshtml');
{ 09 }       EndFrame := TFrameWizFichierFin.Create(nil);
{ 10 }       result := MyShowModal;
{ 11 }       if (result = mrOK) then
{ 12 }         f.copyFrom(tmp);
           finally
{ 13 }       Free;
           end;
         finally
{ 14 }     tmp.Free;
         end;
       end;

IV-B. Créer une application Assistant▲

procedure TFrmMain.FormCreate(Sender: TObject);
begin
  BorderStyle := bsNone;
  ClientWidth := 0;
  ClientHeight := 0;
end;

procedure TFrmMain.FormShow(Sender: TObject);
begin
  // Affichage de l'assistant
  with TDlgAssistant.Create(nil) do
  try
    Caption := 'Le titre...';
    ajouterFrame(...);
    ajouterFrame(...);
    ajouterFrame(...);
    MyShowModal;
  finally
    Free;
  end;
  // Sortie de l'application
  Close;
end;

V-A. Accès aux autres frames▲

V-B. Accès aux données de l'assistant▲

Télécharger l'exemple complet réalisé avec Delphi 6 (17 Ko).
Cet exemple montre un assistant permettant de créer et modifier des objets TMonFichier. L'exemple illustre l'utilisation des différentes méthodes et propriétés de TFrameBaseAssistant ainsi que la navigation conditionnelle (la frame option est affichée en fonction du choix de l'utilisateur). Les classes de l'assistant se trouvent dans le sous-répertoire fichier. Les classes réutilisables se trouvent dans Assistant. Le fichier Util.pas est également à récupérer.