Turbo Vision : Programmation avancée

Les exigences, au niveau de l'interface graphique, se portent principalement sur la simplicité d'utilisation. Notre objectif est de présenter à l'utilisateur toutes les informations dont il a besoin en un seul regard. Ainsi, il doit pouvoir disposer à tout moment de la liste des instructions disponibles et pouvant être exécutées, et du résultat de la dernière commande qu'il a tapée. On veut également connaître la liste des instructions qui ont déjà été exécutées et leur résultat. Afin de gagner en simplicité d'utilisation, et dans l'objectif d'utiliser pleinement tout le potentiel de la librairie Turbo Vision, notre interface graphique doit se baser sur une programmation permettant la prise en compte de tous les types d'évènements que Turbo Vision peut gérer.

Nous avons cependant quelques exigences, tant au niveau de l'interface que des fonctionnalités que notre logiciel doit posséder. En effet, comme notre programme est censé manipuler les secteurs d'une disquette, il est évident que nous devons nécessairement posséder les primitives de base pour accéder aux informations sur le périphérique : nous devons donc avoir une routine de lecture et une routine d'écriture. De plus, les périphériques de stockage possèdent la capacité de pouvoir être totalement et «irrémédiablement» vidés : ceci est le formatage. En résumé, chaque secteur peut donc être lu et écrit, et la disquette peut être formatée, c'est-à-dire effacée. Notre module devra donc permettre l'exécution de ces trois primitives.

III-B-1-a. Le bureau▲

procedure TDisk8Reader.InitDesktop;
var Bounds: TRect;
begin
  Bounds.Assign(0, 0, 80, 49);
  Desktop := New(PDesktop, Init(Bounds));
end;

III-B-1-b. Les barres de menus▲

III-B-1-b-i. La fausse barre de menu▲

Nous allons redéfinir à présent les barres qui entourent l'écran, mais nous allons utiliser une petite astuce. Comme je vous l'ai dit précédemment, nous souhaitons que la barre du haut contienne une horloge. Or la barre du haut est normalement réservée pour l'affichage de la barre de menu, nous allons donc éviter d'afficher une barre de menu pour la remplacer par un champ statique de texte qui prendra toute la largeur de l'écran pour créer l'illusion !

Nous allons tout d'abord définir notre objet qui servira d'horloge. Pour ce faire, nous pouvons utiliser l'objet TStaticText qui permet d'afficher du texte de façon statique : cet objet ne possède donc pas de gestionnaire d'évènements. Ce texte ne peut cependant pas être changé, car il n'existe pas de méthode dans l'objet TStaticText pour le changer, mais la documentation nous indique qu'il existe un champ Text de type PString (c'est-à-dire un pointeur sur une chaîne de caractères). Turbo pascal possède deux procédures pour créer en mémoire (dans le tas) et supprimer des chaînes de caractères : NewStr et DisposeStr. Ce sont ces méthodes que nous utiliserons pour mettre à jour l'affichage de l'horloge. Notre objet possèdera donc trois méthodes :

• le constructeur Init surchargé qui permettra d'initialiser nos propres champs (pour la mise à jour de l'heure) ;
• une méthode SetText qui permettra de changer le texte affiché, en faisant bien attention de bien maîtriser les pointeurs que nous manipulons ;
• une méthode Update dont le but sera de rafraîchir l'affichage de la fausse barre.

Voici la définition de notre type, que nous appellerons TClockStaticText :

 

Sélectionnez

type PClockStaticText = ^TClockStaticText;
     TClockStaticText = object(TStaticText)
     private
       Second, HundredthSecond: Word;
     public
       constructor Init(var Bounds: TRect; AText: String);
       procedure SetText(AText: String);
       procedure Update;
     end;

Et l'implémentation :

 

Sélectionnez

constructor TClockStaticText.Init(var Bounds: TRect; AText: String);
begin
  if not inherited Init(Bounds, AText) then Fail;
  Second := 0;
  HundredthSecond := 0;
end;

procedure TClockStaticText.SetText(AText: String);
begin
  if Text <> Nil then DisposeStr(Text);
  Text := NewStr(AText);
end;

procedure TClockStaticText.Update;
var H, M, S, Sec: Word;
    SH, SM, SS, SSec: String;
begin
  GetTime(H, M, S, Sec);
  If (S * 100 + Sec) - (Second * 100 + HundredthSecond) >= 100 then
  begin
    Second := S;
    HundredthSecond := Sec;
    Str(H, SH); if H < 10 then SH := '0' + SH;
    Str(M, SM); if M < 10 then SM := '0' + SM;
    Str(S, SS); if S < 10 then SS := '0' + SS;
    Str(Sec, SSec);
    SetText(SH + ':' + SM + ':' + SS);
    DrawView;
  end;
end;

Nous voici donc en possession de notre fausse barre ! Il ne nous reste plus qu'à la positionner sur notre bureau, tout en faisant en sorte de ne pas créer de vraie barre de menus. Comme pour la création du bureau, l'objet TApplication possède une variable globale MenuBar de type PMenuView et une méthode InitMenuBar appelée par le constructeur Init, qui est censée créer une barre de menu standard. Nous allons donc redéfinir cette méthode pour ne pas qu'elle crée de barre de menu :

 

Sélectionnez

procedure TDisk8Reader.InitMenuBar;
begin
  MenuBar := Nil;
end;

Nous allons à présent modifier la déclaration de notre type application TDisk8Reader, son constructeur Init et son destructeur Done pour gérer la création et la destruction de la fausse barre. Pour plus de clarté, nous créerons une procédure InitClock permettant d'initialiser l'horloge :

 

Sélectionnez

type TDisk8Reader = object(TApplication)
     private
       ClockStaticText: PClockStaticText;
     public
       constructor Init;
       procedure InitMenuBar; virtual;
       procedure InitStatusLine; virtual;
       procedure InitDesktop; virtual;
       procedure InitClock;
       procedure Idle; virtual;
       destructor Done; virtual;
     end;                        

constructor TDisk8Reader.Init;
begin
  if not inherited Init then Fail;
  SetScreenMode(smCO80 + smFont8x8);
  Redraw;
  InitClock;
end;
                        
procedure TDisk8Reader.InitClock;
var Bounds: TRect;
begin
  Bounds.Assign(0, 0, 80, 1);
  ClockStaticText := New(PClockStaticText, Init(Bounds, ''));
  Desktop^.Insert(ClockStaticText);
end;

destructor TDisk8Reader.Done;
begin
  Dispose(ClockStaticText, Done);
  inherited Done;
end;

Notre barre d'horloge est maintenant mise en place, mais elle n'affiche aucun texte… Il faut utiliser une dernière astuce pour la rendre vivante ! Nous allons en effet mettre à jour l'horloge grâce à la méthode Idle du type TApplication. Cette méthode spéciale est appelée par le gestionnaire d'évènements lorsqu'il n'a pas d'évènement à traiter, ce qui arrive généralement lorsque l'utilisateur ne fait aucune action. Nous allons utiliser cette méthode pour mettre à jour notre horloge :

 

Sélectionnez

procedure TDisk8Reader.Idle;
begin
  inherited Idle;
  ClockStaticText^.Update;
end;

Si vous utilisez la méthode Idle, veillez à toujours appeler la méthode ancêtre Idle de l'objet TApplication parent sinon votre application risque de ne plus se comporter normalement et d'être bloquée pour la gestion des évènements. Veillez également à ne pas faire trop d'opérations dans cette méthode, car, dans ce cas, la gestion d'évènements peut être bloquée.

Dans le constructeur de notre application, nous utilisons la commande SetScreenMode. Cette commande, avec le paramètre smCO80 + smFont8x8 permet de passer le mode vidéo utilisé en couleur et 80 colonnes (paramètre smCO80) et en 50 lignes (paramètre smFont8x8). La méthode Redraw appelée immédiatement après permet de redessiner l'interface en prenant en compte les nouvelles dimensions de l'écran.

III-B-1-b-ii. La barre d'état▲

Nous allons à présent créer notre barre d'état : ici nous n'utiliserons pas d'astuce, nous allons créer une vraie barre d'état ! Comme pour le bureau et la barre de menu, l'objet TApplication dispose d'une variable globale StatusLine de type PStatusLine et d'une méthode InitStatusLine appelée par le constructeur. Comme nous voulons ajouter des « liens » à notre barre en plus des « liens » normaux, nous devons redéfinir un objet PStatusLine avec les bons paramètres. Nous voulons donc que notre barre contienne un premier lien permettant de quitter l'application et trois autres liens permettant d'afficher diverses fenêtres (nous verrons plus loin quelles fenêtres seront affichées et comment elles seront construites). Nous obtenons le code suivant :

 

Sélectionnez

procedure TDisk8Reader.InitStatusLine;
var Bounds: TRect;
begin
  Bounds.Assign(0, 49, 80 ,50);
  StatusLine := New(PStatusLine, Init(Bounds, NewStatusDef(0, 0,
            NewStatusKey('~Alt+X~ Exit', kbAltX, cmQuit,
            NewStatusKey('~Alt+L~ Log', kbAltL, cmShowLogDialog,
                NewStatusKey('~Alt+M~ Memory', kbAltM, cmShowMemoryDialog,
            NewStatusKey('~Alt+A~ About', kbAltA, cmShowAboutDialog, Nil)))), Nil)));
end;

La construction des barres d'état, tout comme celle des barres de menus, est intéressante à analyser : en effet, il faut définir les éléments à utiliser de façon imbriquée. Dans notre cas, nous définissons tout d'abord un objet TStatusLine : le constructeur de TStatusLine possède un paramètre qui est un pointeur vers un objet TStatusDef (qui représente une ligne dans la barre d'état). Pour créer les différents éléments, nous utilisons ensuite les fonctions NewStatusDef et NewStatusKey, qui prennent chacune en paramètre un pointeur vers l'élément suivant. Si ce paramètre est Nil, alors l'élément créé est le dernier de la liste.

III-B-1-b-iii. La palette de couleurs▲

Nous allons utiliser ici une dernière astuce, qui peut être très amusante… En effet, l'objet TApplication possède une méthode GetPalette qui retourne un pointeur de type PPalette vers la palette utilisée par l'application. Or ce type PPalette est en réalité un pointeur vers le type TPalette, qui est lui-même un type équivalent au type String. La documentation n'est pas très explicite pour ce type TPalette, mais comme il existe en tout 63 couleurs, on en déduit donc que la palette de l'application est une chaîne de caractères dont la taille est de 63 caractères. Chacune de ces 63 valeurs représente une couleur correspondant à un élément précis des interfaces : il y a par exemple une couleur définissant la couleur du bureau, une pour la couleur des menus, une autre pour le fond des fenêtres, etc. Il est possible de presque tout changer ! La liste des couleurs utilisées dans les interfaces Turbo Vision est néanmoins documentée dans la section « Turbo_Vision_palettes » de l'aide, on peut également connaître le détail des couleurs en cherchant le mot-clé CColor. Nous allons voir comment modifier la palette courante. L'opération consiste à redéfinir la fonction GetPalette de notre objet TApplication, en ayant au préalable défini notre propre palette :

 

Sélectionnez

const CAppPalette = #$78#$70#$78#$74#$20#$74#$78#$73#$7F#$7A +
                    #$31#$31#$1E#$71#$00#$2F#$3F#$3A#$13#$13 +
                    #$3E#$21#$00#$70#$7F#$13#$78#$74#$70#$7F +
                    #$00#$70#$7F#$7A#$13#$13#$70#$70#$7F#$7E +
                    #$20#$2B#$2F#$78#$2E#$70#$30#$3F#$3E#$1F +
                    #$2F#$1A#$20#$72#$31#$31#$30#$2F#$3E#$31 +
                    #$13#$00#$00;

function TDisk8Reader.GetPalette: PPalette;
const P: String[Length(CAppPalette)] = CAppPalette;
begin
  GetPalette := @P;
end;

La méthode GetPalette permet donc de charger notre propre palette et est appelée à chaque fois que l'application a besoin de dessiner un élément de l'interface. Pour cette application, j'ai, entre autres, changé les couleurs des éléments lorsqu'ils sont sélectionnés et la couleur de fond du champ de saisie des commandes.

Voici le résultat obtenu à la fin de ces différents ajouts :

Nous allons détailler ici les principaux composants de la fenêtre principale et leur programmation :

• tout d'abord un champ où l'utilisateur pourra entrer la commande qu'il souhaite utiliser ;
• une liste qui affichera les différentes commandes possibles pour l'utilisateur ;
• enfin une liste déroulante qui permettra d'afficher les données relatives aux secteurs de la disquette.

III-B-2-a. Le champ de commande▲

procedure TCommandInputLine.HandleEvent(var Event: TEvent);
var Command: String;
begin
  if ((Event.What = evKeyDown) and (Event.CharCode in CorrectChars)) then
  begin
    case Event.CharCode of
    #13 : begin
            Event.What := evCommand;
            Event.Command := cmExecuteCommand;
          end;
    #8  : begin
            GetData(Command);
            Command := Copy(Command, 0, Length(Command) - 1);
            SetData(Command);
            SelectAll(False);
            Event.What := evCommand;
            Event.Command := cmBuildCommandListBox;
          end
    else begin
           GetData(Command);
           Command := Command + Event.CharCode;
           SetData(Command);
           SelectAll(False);
           Event.What := evCommand;
           Event.Command := cmBuildCommandListBox;
         end;
    end;
    Event.InfoPtr := Nil;
    PutEvent(Event);
  end;
  if ((Event.What = evMouseDown) and (Event.Buttons = mbLeftButton) and (Event.Double)) then
  begin
    Event.What := evCommand;
    Event.Command := cmExecuteCommand;
  end;
  inherited HandleEvent(Event);
end;

III-B-2-b. La gestion des listes déroulantes▲

III-B-2-c. La liste des commandes▲

Nous allons à présent nous intéresser à la liste des commandes, reconstruite à chaque changement. Pour présenter ces commandes, nous allons nous baser sur l'objet TListBox qui possède un comportement similaire à celui que nous souhaitons avoir pour notre liste. Comme précédemment, il suffira de redéfinir la méthode HandleEvent afin de rajouter une subtilité : l'utilisateur doit pouvoir choisir la commande à partir de la liste, en la sélectionnant puis en appuyant sur la touche Entrée ou Espace, ou en double-cliquant dessus. Analysons le code de cette méthode :

 

Sélectionnez

procedure TCommandListBox.HandleEvent(var Event: TEvent);
begin
  if ((Event.What = evKeyDown) and ((Event.CharCode = #13) or (Event.CharCode = #32))) then
  begin
    Event.What := evCommand;
    Event.Command := cmChangeCommandFromListBox;
    Event.InfoPtr := Nil;
    PutEvent(Event);
  end;
  if ((Event.What = evMouseDown) and (Event.Buttons = mbLeftButton) and (Event.Double)) then
  begin
    Event.What := evCommand;
    Event.Command := cmChangeCommandFromListBox;
    Event.InfoPtr := Nil;
    PutEvent(Event);
  end;
  inherited HandleEvent(Event);
end;

Dans ce cas-ci, nous gérons les évènements « touche pressée », qui peuvent être les touches Entrée (caractère #13) ou Espace (#32), et les évènements « bouton pressé » si le bouton gauche a été double-cliqué. À la détection de ces évènements par le gestionnaire de la liste, un nouvel évènement est envoyé, ayant pour commande cmChangeCommandFromListBox. Nous verrons plus tard comment cet évènement est géré.

III-B-2-d. La liste des résultats▲

Pour définir ce composant, nous allons également nous baser sur l'objet TListBox, mais nous allons modifier quelque peu son comportement. Le but est en effet d'afficher les informations récupérées lors de la lecture des secteurs de la disquette : ces données sont récupérées dans un objet de type TBuffer, qui est en réalité un tableau de 512 octets contenant des entiers courts non signés (Byte). Il nous faut donc un mécanisme permettant d'afficher les données contenues dans les tampons obtenus, de façon claire et précise.

Intéressons-nous à présent à l'implémentation de l'objet TBufferDump qui se base sur TListBox. Rappelons tout d'abord que l'objet TListBox possède un attribut List de type PCollection, pointant sur la collection d'objets que la liste doit afficher (typiquement des chaînes de caractères, l'objet utilisé est alors PStringCollection au lieu de PCollection). C'est cet objet List que nous devrons modifier pour mettre à jour la liste et y incorporer nos propres valeurs. Ici nous admettrons que l'initialisation du champ List et de l'objet liste chaînée est effectuée dans le constructeur de l'objet TBufferDump. Voyons l'implémentation de la procédure LoadFromBuffer qui convertit les données du tampon obtenu en paramètre en chaînes de caractères :

 

Sélectionnez

procedure TBufferDump.LoadFromBuffer(Buffer: TBuffer);
var I, J: Word;
    S: String;
begin
  List^.FreeAll;
  for I := 0 to 31 do
  begin
    S := Hexa16(I * 16) + 'h   ';
    for J := 0 to 15 do S := S + Hexa8(Buffer[I * 16 + J]) + ' ';
    S := S + '  ';
    for J := 0 to 15 do
    begin
      if Chr(Buffer[I * 16 + J]) in CorrectChars then
        S := S + Chr(Buffer[I * 16 + J])
      else
        S := S + '.';
    end;
    List^.Insert(NewStr(S));
  end;
  SetRange(List^.Count);
  DrawView;
end;

Notre première action est de vider de ses contenus la liste chaînée et la collection de Strings. Vient ensuite la boucle permettant de mettre en forme les données du tampon, qui sont traitées selon notre gré (converties en hexadécimal et/ou affichées). Lorsque la conversion est terminée pour toutes les données du buffer, la collection List est remplie avec le contenu de la liste chaînée. SetRange permet de définir le nombre d'éléments visibles à l'écran et l'appel à la procédure héritée DrawView permet de redessiner le composant à l'écran, pour que les modifications soient visibles par l'utilisateur.

Nous pouvons voir ici un exemple du résultat obtenu dans ce composant, après l'exécution de la commande « Read » sur un secteur de la disquette :

Commençons par la fenêtre des logs : cette fenêtre doit permettre d'afficher la liste des opérations qui ont été effectuées par l'utilisateur, avec l'heure, et les erreurs probables. La liste des messages devra donc être stockée en mémoire, nous utiliserons l'objet TStringLinkedList, que nous avons créé, pour faire ceci simplement.

Les méthodes de l'objet TStringLinkedList sont les suivantes :

• procedure Add(Value: String) ;
• function GetValueAt(Index: Integer): Pstring ;
• procedure Clear ;
• function GetCount : Integer.

La procédure Add permet donc d'ajouter la chaîne passée en paramètre à la liste, la fonction GetValueAt permet de récupérer successivement les chaînes de la liste selon leur index (ou leur position). La procédure Clear vide la liste chaînée, et enfin la fonction GetCount renvoie le nombre d'éléments dans la liste. Les éléments de la liste sont numérotés à partir de 1 jusqu'à Count.

Voyons ensuite la déclaration du type TLogDialog :

type PLogDialog = ^TLogDialog;
     TLogDialog = object(TDialog)
     private
       LogListBox: PListBox;
       LogScrollBar: PScrollBar;
       OKButton, ClearButton: PButton;
       Log: PStringLinkedList;
     public
       constructor Init(var Bounds: TRect; ATitle: TTitleStr; LogToShow: PStringLinkedList);
       procedure HandleEvent(var Event: TEvent); virtual;
       destructor Done; virtual;
     end;

Comme on peut le voir, notre fenêtre héritera de TDialog, qui est l'objet typique pour ce genre de présentations. TDialog possède plusieurs avantages, par rapport à TWindow : les boîtes de dialogues ne sont pas redimensionnables, mais peuvent être déplacées et fermées, et elles sont obligatoirement modales, c'est-à-dire qu'elles doivent être fermées pour que l'application puisse continuer à s'exécuter normalement.

Pour notre objet TLogDialog, nous définissons :

• une liste déroulante qui affichera les messages de logs avec sa barre de défilement ;
• deux boutons, un pour effacer le log, et un autre pour fermer la boîte de dialogue ;
• un pointeur sur une liste chaînée de chaînes de caractères, ce pointeur pointera vers la variable globale Log, qui stockera les messages.

Regardons brièvement le constructeur de cet objet :

constructor TLogDialog.Init(var Bounds: TRect; ATitle: TTitleStr; LogToShow: PStringLinkedList);
var I: Integer;
begin
  if not inherited Init(Bounds, ATitle) then Fail;
  Bounds.Assign(28, 14, 41, 16);
  OKButton := New(PButton, Init(Bounds, 'OK', cmCancel, bfDefault));
  Insert(OKButton);
  Bounds.Assign(13, 14, 26, 16);
  ClearButton := New(PButton, Init(Bounds, 'Clear Log', cmClearLogCommand, bfNormal));
  Insert(ClearButton);
  Bounds.Assign(53, 2, 54, 12);
  LogScrollBar := New(PScrollBar, Init(Bounds));
  Insert(LogScrollBar);
  Bounds.Assign(2, 2, 53, 12);
  LogListBox := New(PListBox, Init(Bounds, 1, LogScrollBar));
  Insert(LoglistBox);
  LogListBox^.List := New(PStringCollection, Init(10, 1));
  for I := 1 to LogToShow^.GetCount do LogListBox^.List^.Insert(LogToShow^.GetValueAt(I));
  Log := LogToShow;
  LogListBox^.SetRange(LogListBox^.List^.Count);
  LogListBox^.DrawView;
end;

Nous voyons tout d'abord la création des éléments de l'interface : liste et boutons. Enfin, une boucle For permet de copier les messages du log vers la collection de la liste déroulante. Afin de gérer le bouton pour effacer le log, nous devons redéfinir le gestionnaire d'évènements pour cette fenêtre, ceci est fait en redéfinissant la procédure HandleEvent :

procedure TLogDialog.HandleEvent(var Event: TEvent);
var I: Integer;
begin
  if Event.Command = cmClearLogCommand then
  begin
    Log^.Clear;
    LogListBox^.List^.DeleteAll;
    LogListBox^.SetRange(LogListBox^.List^.Count);
    LogListBox^.DrawView;
  end
  else inherited HandleEvent(Event);
end;

Si l'évènement est une commande cmClearLogCommand (commande envoyée lors du clic sur le bouton ClearButton), alors la liste chaînée pointée par l'attribut Log est vidée, et la collection de la liste est aussi vidée, et la liste est redessinée.

Voici le résultat obtenu pour cette boîte de dialogue :

Attaquons-nous maintenant à la fenêtre « mémoire » dont le but est de donner la quantité de mémoire restante sur le tas. Pour cela, nous allons définir un objet TMemoryDialog dérivant de TDialog. Nous placerons au milieu de la fenêtre un simple texte qui affichera la quantité de mémoire disponible. Voici la déclaration du type TMemoryDialog :

type PMemoryDialog = ^TMemoryDialog;
     TMemoryDialog = object(TDialog)
     private
       MemoryStaticText: PStaticText;
       OKButton: PButton;
     public
       constructor Init(var Bounds: TRect; ATitle: TTitleStr);
       destructor Done; virtual;
     end;

La redéfinition du constructeur permettra de définir les deux objets MemoryStaticText et OKButton. Voyons le constructeur :

constructor TMemoryDialog.Init(var Bounds: TRect; ATitle: TTitleStr);
var SMemAvail: String;
begin
  if not inherited Init(Bounds, ATitle) then Fail;
  Str(MemAvail:6, SMemAvail);
  Bounds.Assign(2, 2, 34, 3);
  MemoryStaticText := New(PStaticText, Init(Bounds, 'Available Memory : ' + SMemAvail + ' Bytes'));
  Insert(MemoryStaticText);
  Bounds.Assign(12, 5, 22, 7);
  OKButton := New(PButton, Init(Bounds, 'OK', cmCancel, bfDefault));
  Insert(OKButton);
end;

Dans ce cas-ci, nous récupérons la quantité de mémoire disponible lors de l'appel au constructeur : comme la fenêtre est recréée à chaque fois lorsqu'on veut l'afficher, nous obtiendrons toujours la bonne quantité. Nous n'avons pas besoin de redéfinir le gestionnaire d'évènements de cette boîte de dialogue, car nous avons défini le bouton OKButton de telle façon qu'il envoie la commande cmCancel à la boîte de dialogue le contenant : ainsi le gestionnaire d'évènement standard de l'objet TDialog (et donc des objets héritant de TDialog) sait traiter naturellement la commande cmCancel, qui provoque la fermeture de la boîte de dialogue.

Le principe est le même pour la fenêtre « About » :

• nous créons un objet TAboutDialog dérivant de TDialog pour bénéficier des avantages des boîtes de dialogues ;
• nous redéfinissons le constructeur afin qu'il effectue les opérations que nous souhaitons.

Cette fenêtre de choix est utilisée lors des appels aux primitives de lecture et d'écriture des secteurs de la disquette : ce dialogue permet à l'utilisateur de choisir le secteur auquel accéder par l'intermédiaire du triplet (Tête, Cylindre, Secteur). Nous avons donc pour cette fenêtre trois champs d'entrée qui ne doivent accepter que des bytes, compris entre deux valeurs différentes à chaque fois :

• 0 ou 1 pour la tête ;
• 0 à 79 pour la piste ;
• 1 à 18 pour le secteur.

Pour obtenir cela, nous allons définir deux nouveaux objets : tout d'abord l'objet TByteInputLine dérivant de TInputLine et servant à la saisie des nombres, et ensuite TByteValidator dérivant de TFilterValidator qui permettra de valider ou non que les nombres entrés par l'utilisateur soient corrects, c'est-à-dire formés de chiffres et compris entre les valeurs énoncées plus haut.

Nous pouvons à présent définir l'objet TChooseDialog :

type PChooseDialog = ^TChooseDialog;
     TChooseDialog = object(TDialog)
     private
       HeadStaticText: PStaticText;
       HeadInputLine: PByteInputLine;
       CylinderStaticText: PStaticText;
       CylinderInputLine: PByteInputLine;
       TrackStaticText: PStaticText;
       TrackInputLine: PByteInputLine;
       OKButton : PButton;
       CancelButton: PButton;
     public
       constructor Init(var Bounds: TRect; ATitle: TTitleStr);
       destructor Done; virtual;
     end;

L'appel à cette boîte de dialogue se fera néanmoins de façon particulière. En effet, nous avons besoin de connaître les valeurs que l'utilisateur a entrées après qu'il ait validé la boîte de dialogue : ces valeurs doivent être donc stockées quelque part. La fonction ExecuteDialog de l'objet TApplication prévoit ce genre de mécanisme : il est possible de passer à la boîte de dialogue un pointeur vers une zone tampon où des données d'échanges sont stockées. Lors de la construction de la boîte de dialogue, cette zone de mémoire est lue séquentiellement et les champs de la boîte sont remplis avec les valeurs lues. Lors de la destruction, le processus inverse se déroule, les données des différents champs sont écrites dans cette zone mémoire, et peuvent ensuite être récupérées. Nous utiliserons le type TDataBuffer que nous avons défini, pour déterminer cette zone d'échange. Le principal problème de ce mécanisme est qu'il faut convertir les données en caractères d'abord, car seuls les flux de caractères sont gérés par cette méthode.

Afin de simplifier ces opérations de conversion, nous avons défini une méthode dans notre objet dérivant de TApplication, qui rassemble toutes les opérations nécessaires :

function TDisk8Reader.ExecuteChooseDialog(ATitle: TTitleStr; var Head, Cylinder, Track: Byte): Word;
var Bounds: TRect;
    DataBuffer: PDataBuffer;
    SHead, SCylinder, STrack: String;
    Code: Integer;
begin
  DataBuffer := New(PDataBuffer);
  FillChar(DataBuffer^, 9, 0);
  Str(Head, SHead);
  Str(Cylinder, SCylinder);
  Str(Track, STrack);
  Move(SHead, DataBuffer^[0], Length(SHead) + 1);
  Move(SCylinder, DataBuffer^[3], Length(SCylinder) + 1);
  Move(STrack, DataBuffer^[6], Length(STrack) + 1);
  Bounds.Assign(27, 19, 52, 31);
  ExecuteChooseDialog := ExecuteDialog(New(PChooseDialog, Init(Bounds, ATitle)), DataBuffer);
  Move(DataBuffer^[0], SHead, DataBuffer^[0] + 1);
  Move(DataBuffer^[3], SCylinder, DataBuffer^[3] + 1);
  Move(DataBuffer^[6], STrack, DataBuffer^[6] + 1);
  Val(SHead, Head, Code);
  Val(SCylinder, Cylinder, Code);
  Val(STrack, Track, Code);
  Dispose(DataBuffer);
end;

À la fin de l'exécution de cette fonction, les variables Head, Cylinder et Track passées en paramètre par adresse auront les valeurs que l'utilisateur a entrées.

Afin de vérifier la validité des données entrées par l'utilisateur, nous allons définir un objet TByteValidator permettant d'effectuer les vérifications nécessaires et héritant de l'objet TFilterValidator. TFilterValidator possède deux méthodes intéressantes :

• IsValid, qui détermine si la chaîne de caractères passée en paramètre est correcte, c'est-à-dire si elle ne comporte pas de caractère non autorisé ;
• Error, qui est appelée lorsque le validateur détecte un caractère non autorisé dans la chaîne qu'il analyse.

La liste des caractères valides pour ce validateur est renseignée dans le constructeur de TFilterValidator. Pour notre objet, la liste des caractères autorisés est uniquement constituée des chiffres, car notre validateur ne doit fonctionner que pour des nombres entiers de type byte. Nous devrons passer cependant une borne minimale et une borne maximale au constructeur de TByteValidator afin qu'il vérifie bien que le nombre entré par l'utilisateur est dans le bon intervalle borné.

type PByteValidator = ^TByteValidator;
     TByteValidator = object(TFilterValidator)
     private
       Name: String;
       Min, Max: Byte;
     public
       constructor Init(AName: String; AMin, AMax: Byte);
       procedure Error; virtual;
       function IsValid(const S: String): Boolean; virtual;
     end;

                    
constructor TByteValidator.Init(AName: String; AMin, AMax: Byte);
var Chars: TCharSet;
begin
  Chars := ['0'..'9'];
  if not inherited Init(Chars) then Fail;
  Name := AName;
  Min := AMin;
  Max := AMax;
end;

procedure TByteValidator.Error;
begin
  MessageBox('Incorrect ' + Name + ' number...', Nil, mfWarning + mfOKButton);
end;

function TByteValidator.IsValid(const S: String): Boolean;
var Value: Byte;
    Code: Integer;
begin
  if Length(S) <> 0 then
  begin
    Val(S, Value, Code);
    IsValid := ((inherited IsValid(S)) and (Value >= Min) and (Value <= Max));
  end
  else IsValid := False;
end;

Ici, notre méthode Error se contente juste d'afficher une boîte de dialogue contenant un message d'erreur. La méthode IsValid se comporte comme prévu : elle vérifie tout d'abord que la chaîne est valide (c'est-à-dire qu'elle ne contient pas de caractère non autorisé), et ensuite que le nombre entré par l'utilisateur est bien compris entre la borne inférieure et la borne supérieure de l'intervalle autorisé.

Pour la lecture d'un secteur, nous utiliserons la sous-fonction 02h de l'interruption 13h. Cette interruption prend en paramètre AL, le nombre de secteurs à lire (ici 1), CH le numéro de cylindre, CL le numéro de secteur, DH le numéro de tête et DL le numéro du lecteur disquette (ici 0, qui désigne le premier lecteur de disquette reconnu). ES:BX représente un pointeur vers une zone mémoire où seront stockées les données lues. Voici le code de cette méthode :

procedure TFloppyHandler.ReadFloppy(Head, Cylinder, Sector: Byte; Buffer: TBuffer); assembler;
asm
  PUSHA;
  MOV AH, 00h;
  MOV DL, 00h;
  INT 13h;
  MOV [FloppyLastError], AH;
  CMP AH, 0;
  JE @@OK;
  JMP @@Fin;
  @@OK : MOV AH, 02h;
         MOV AL, 01h;
         MOV CH, Cylinder;
         MOV CL, Sector;
         MOV DH, Head;
         MOV DL, 00h;
         LES BX, Buffer;
         INT 13h;
         MOV [FloppyLastError], AH;
  @@Fin : POPA;
end;

Après chaque opération, l'attribut FloppyLastError est mis à jour avec la dernière valeur renvoyée par le contrôleur de disquette.

Pour l'écriture, nous utiliserons la sous-fonction 03h, les paramètres étant les mêmes que pour la fonction de lecture :

procedure TFloppyHandler.WriteFloppy(Head, Cylinder, Sector: Byte; Buffer: TBuffer); assembler;
asm
  PUSHA;
  MOV AH, 00h;
  MOV DL, 00h;
  INT 13h;
  MOV [FloppyLastError], AH;
  CMP AH, 0;
  JE @@OK;
  JMP @@Fin;
  @@OK :  MOV AH, 03h;
          MOV AL, 01h;
          MOV CH, Cylinder;
          MOV CL, Sector;
          MOV DH, Head;
          MOV DL, 00h;
          LES BX, Buffer;
          INT 13h;
          MOV [FloppyLastError], AH;
  @@Fin : POPA;
end;

Dans ce cas-ci, nous utiliserons la sous-fonction 05h, qui permet de formater un cylindre entier. L'opération de formatage permet de reformer correctement un cylindre et les secteurs le constituant, en leur attribuer les bons numéros de tête, de cylindre et de secteur et en leur « redonnant » la bonne taille (dans notre cas 512 octets). De cette façon, le contenu des secteurs est effacé définitivement. Cette opération peut créer des dommages importants, si les valeurs que vous entrez ne sont pas conformes. De par ce fait, l'auteur ne pourra être tenu responsable de tout dommage, si vous n'utilisez pas le bon matériel (disquette double face 1.44 Mo) ou les bonnes valeurs.

Voici le code de cette méthode :

procedure TFloppyHandler.FormatFloppy(Head, Cylinder: Byte);
var Buffer: array[0..71] of Byte;
    I: Integer;
    PBuffer: Pointer;
begin
  for I := 0 to 17 do
  begin
    Buffer[(I * 4) + 0] := Cylinder;
    Buffer[(I * 4) + 1] := Head;
    Buffer[(I * 4) + 2] := I + 1;
    Buffer[(I * 4) + 3] := 2;
  end;
  PBuffer := @Buffer;
  asm
  PUSHA;
  MOV AH, 05h;
  MOV AL, 18;
  MOV CH, Cylinder;
  MOV DH, Head;
  MOV DL, 00h;
  LES BX, PBuffer;
  INT 13h;
  MOV [FloppyLastError], AH;
  POPA;
  end;
end;

Ici le paramètre Buffer doit contenir une table regroupant le numéro de cylindre, le numéro de tête, le numéro de secteur et la taille du secteur (0 = 128 octets, 1 = 256 octets, 2 = 512 octets) pour tous les secteurs du cylindre. Puisque nos disquettes 3 pouces ½ 1.44 Mo possèdent 18 secteurs par cylindre, la taille du tableau Buffer est donc de 18 * 4 octets, soit 72 octets.

Comme il n'existe pas d'objet de type barre de progression dans la bibliothèque Turbo Vision, nous allons en créer un de toutes pièces. Il faut tout d'abord savoir que tous les composants doivent hériter de l'objet TView, qui est l'objet ancêtre de tous les composants de l'interface. Pour définir notre composant, nous devons donc redéfinir les méthodes de TView à l'intérieur de notre nouvel objet. La méthode héritée de TView la plus intéressante est certainement Draw : c'est cette méthode qui permet d'afficher le composant à l'écran. Nous allons également redéfinir la palette de ce composant afin qu'il possède les couleurs que nous désirons. Voici le code qui lui est associé :

type PProgressBar = ^TProgressBar;
     TProgressBar = object(TView)
     private
       Min, Max, Position: Integer;
     public
       constructor Init(var Bounds: TRect; AMin: Integer; AMax: Integer);
       procedure Draw; virtual;
       procedure Progress(Value: Integer);
       function GetPalette: PPalette; virtual;
     end;
     
constructor TProgressBar.Init(var Bounds: TRect; AMin: Integer; AMax: Integer);
begin
  if not inherited Init(Bounds) then Fail;
  Min := AMin;
  Max := AMax;
  Position := Min;
end;

procedure TProgressBar.Progress(Value: Integer);
begin
  Position := Position + Value;
  if Position > Max then Position := Max;
end;

procedure TProgressBar.Draw;
var I, J: Integer;
    SPosition: String;
begin
  inherited Draw;
  for I := 0 to Size.X - 1 do
    for J := 0 to Size.Y - 1 do
    begin
      if I <= (Position / Max * Size.X) then
        WriteStr(I, J, #177, 1)
      else
        WriteStr(I, J, ' ', 1);
    end;
  str(Position / Max * 100:3:0, SPosition);
  SPosition := SPosition + '%';
  WriteStr(Size.X div 2 - 2, Size.Y div 2 , SPosition, 1);
end;

function TProgressBar.GetPalette: PPalette;
const P: String[Length(CAppPalette)] = CProgressBar;
begin
  GetPalette := @P;
end;

Le fonctionnement de ce composant est simple : en fonction de l'avancement de la tâche, représenté par la valeur de Position dans l'intervalle formé par Min et Max, il dessine le caractère ASCII 177 ou un espace, et ceci jusqu'à la fin de la barre. La barre se remplit donc de gauche à droite et affiche le pourcentage équivalent au centre. En ce qui concerne l'affichage à proprement parler, il faut impérativement utiliser les fonctions WriteStr, WriteChar, WriteBuf ou WriteLine. Concernant les modifications pour la palette, il suffit de redéfinir la méthode GetPalette de TView. Le fonctionnement de la palette pour les composants est cependant totalement différent de celui des palettes utilisées pour l'application. En effet, un composant doit utiliser la palette de la fenêtre ou de la boîte de dialogue qui le contient : ainsi, la palette d'un composant ne correspond plus à une liste de couleurs (comme pour la palette application), mais à un index dans la palette de son conteneur. Dans notre cas, la constante CProgressBar vaut #6, ce qui signifie que notre barre de progression devra utiliser la sixième couleur de la palette de son conteneur. Nous avons choisi d'utiliser une fenêtre comme conteneur, la couleur sera donc $1E, ce qui correspond à la combinaison d'un fond bleu foncé (les 4 bits de poids fort) et d'une police jaune (les 4 bits de poids faible). Pour connaître les palettes exactes des autres composants de Turbo Vision, vous pouvez vous reporter au mot-clé CColor de l'aide de Turbo Pascal.

Tout d'abord, pourquoi le choix de la fenêtre ? Cette question est légitime, car l'utilisation d'une boîte de dialogue était également possible. Pour ce cas-ci, nous avons décidé de laisser le traitement du formatage dans le programme principal, et de n'utiliser la fenêtre que pour afficher la progression : ceci n'est possible que parce que les fenêtres ne sont pas modales, contrairement aux boîtes de dialogues (vous verrez par la suite comment sont effectués l'affichage et la mise à jour de la fenêtre). Voyons tout de suite le code associé à notre fenêtre :

type PFormatAllWindow = ^TFormatAllWindow;
     TFormatAllWindow = object(TWindow)
     private
       ProgressBar: PProgressBar;
     public
       constructor Init(var Bounds: TRect; ATitle: TTitleStr; ANumber: Integer; AMin: Integer; AMax: Integer);
       procedure Progress(Value: Integer);
       destructor Done; virtual;
     end;
     
constructor TFormatAllWindow.Init(var Bounds: TRect; ATitle: TTitleStr; ANumber: Integer; AMin: Integer; AMax: Integer);
const Commands: TCommandSet = [cmClose];
begin
  if not inherited Init(Bounds, ATitle, ANumber) then Fail;
  DisableCommands(Commands);
  Flags := $0000;
  Bounds.Assign(2, 2, Bounds.B.X - Bounds.A.X - 2, 5);
  ProgressBar := New(PProgressBar, Init(Bounds, AMin, AMax));
  Insert(ProgressBar);
end;

procedure TFormatAllWindow.Progress(Value: Integer);
begin
  ProgressBar^.Progress(Value);
end;

destructor TFormatAllWindow.Done;
begin
  dispose(ProgressBar, Done);
  inherited Done;
end;

Le seul point intéressant ici est dans le constructeur, où l'attribut Flags est modifié : cet attribut permet de modifier l'apparence de la fenêtre. En y attribuant la valeur 0, la fenêtre ne peut être ni déplacée ni fermée, ni redimensionnée ni « dépliée ». Enfin, la commande DisableCommand permet de désactiver un ensemble de commandes qui ne seront plus traitées par la fenêtre : ici, nous désactivons la commande de fermeture, l'utilisateur n'aura donc aucun moyen de fermer cette fenêtre.

Il est temps à présent de mettre en place notre fenêtre pour la fonction de formatage complet. Comme vu précédemment, nous allons modifier la procédure HandleEvent de notre objet Application. Pour information, le formatage complet s'effectue à l'aide de deux boucles imbriquées, chacune faisant varier un élément du couple (Tête, Cylindre) : ceci garantit le formatage total de la disquette. Voyons à présent les instructions permettant d'afficher et de mettre à jour automatiquement la fenêtre :

if ((Command = 'FORMATALL') and (MessageBox('Format All ?', Nil, mfWarning + mfYesButton + mfCancelButton) = cmYes)) then
begin
  Bounds.Assign(13, 21, 68, 29);
  FormatAllWindow := New(PFormatAllWindow, Init(Bounds, 'Format All', 0, 0 , 80 * 2));
  InsertWindow(FormatAllWindow);
  Cylinder := 0;
  while ((Cylinder <= 79)) and (FloppyHandler^.GetFloppyLastError = 0) do
  begin
    Head := 0;
    while ((Head <= 1)) and (FloppyHandler^.GetFloppyLastError = 0) do
    begin
      FloppyHandler^.FormatFloppy(Head, Cylinder);
      Head := Head + 1;
      FormatAllWindow^.Progress(1);
      FormatAllWindow^.Redraw;
    end;
    Cylinder := Cylinder + 1;
  end;
  FormatAllWindow^.Close;
  if FloppyHandler^.GetFloppyLastError = 0 then
  begin
    ClockStaticText^.GetText(STime);
    Log^.Add(STime + '  FormatAll Success');
    MessageBox('FormatAll Success !',  Nil, mfInformation + mfOKButton);
  end
  else
  begin
    ClockStaticText^.GetText(STime);
    Log^.Add(STime + '  FormatAll Failure');
    MessageBox('FormatAll Failure...' + #13#10 + 'Error : ' + FloppyHandler^.GetFloppyLastErrorMessage, Nil, mfInformation + mfOKButton);
  end;
end;

L'affichage se fait grâce à l'appel de la méthode héritée de TApplication, InsertWindow. La mise à jour de l'affichage est effectuée à l'intérieur de la boucle : l'utilisation de la méthode Progress permet de mettre à jour la barre de progression, et la méthode Redraw permet de réafficher immédiatement la fenêtre.

Il existe cependant un désavantage à utiliser de telles boucles : lors de l'exécution, il peut alors arriver que la charge de travail soit trop importante, et ainsi le gestionnaire d'évènements ne peut plus traiter tous les évènements qu'il reçoit. Il en résulte une certaine congestion au niveau de l'exécution des évènements : ceci peut être une source de gêne pour certains utilisateurs. Il n'était malheureusement pas possible dans ce cas de mettre en place un mécanisme différent de façon simple. Lorsque vous programmez dans des environnements possédant la gestion des évènements, veillez à ne jamais négliger l'aspect de congestion, pour le confort des utilisateurs.