DP Tool Club 31/CDASC_31_1996_juillet_aout.iso/index/source/interfac.pas

Pascal/Delphi Source File | 1996-06-14 | 28.9 KB | 1,068 lines

{ Pourquoi ne pas avoir fait une unite, bonne question, question suivante SVP!

Bon, pour ne pas surcharger le source de TROUVE.PAS, j'ai transferé le source
de l'interface ici, c'est crado mais c'est du temporaire qui dure!}

TYPE pObjet = ^objet ;
     objet = OBJECT
                   changement : Boolean ;
                   etendu     : Boolean ;
                   X, Y, l, h : Integer ;

                   CONSTRUCTOR init (PosX, PosY,
                                     Largeur, Hauteur : Integer) ;
                   PROCEDURE reagit (CH : Char) ;                    VIRTUAL ;
                   FUNCTION focus : Boolean ;
                   PROCEDURE redraw ;                                VIRTUAL ;
                   DESTRUCTOR done ;                                 VIRTUAL ;
             END ;

     pListe = ^oListe ;
     oListe = OBJECT (objet)
                     courant,
                     queue,
                     relatif,
                     tete    : pelt ;

                     CONSTRUCTOR init ( PosX, PosY,
                                        largeur, hauteur : Integer ) ;
                     PROCEDURE ajoute ( elt : pFichier ) ;
                     PROCEDURE reagit ( CH: Char) ;                  VIRTUAL ;
                     PROCEDURE redraw ;                              VIRTUAL ;
                     DESTRUCTOR done ;                               VIRTUAL ;
              END ;


     pSaisie = ^oSaisie ;
     oSaisie = OBJECT (objet)
                      maxi   : Integer ;
                      chaine : String  ;

                      CONSTRUCTOR init (posx, posy, max : Integer ) ;
                      PROCEDURE reagit (CH : Char) ;                 VIRTUAL ;
                      PROCEDURE redraw ;                             VIRTUAL ;
               END ;

     pBoutonCocher = ^oBoutonCocher ;
     oBoutonCocher = OBJECT (objet)
                            etat   : Boolean ;
                            option : String  ;

                            CONSTRUCTOR init (posx, posy : Integer ;
                                              chaine : String;
                                              debut : Boolean ) ;
                            PROCEDURE reagit ( CH : Char ) ;         VIRTUAL ;
                            PROCEDURE redraw ;                       VIRTUAL ;
                     END ;

     { Je définit un fils de bouton à cocher car il a un comportement
       particulier, il désactive un ensemble de fichier dans la liste des
       fichiers de descriptions, ainsi la partie interface peut être séparé au
       maximum de la partie code proprement dîte. }

     pBoutonCocherBis = ^oBoutonCocherBis ;
     oBoutonCocherBis = OBJECT (oBoutonCocher)
                              num : Byte ;

                              PROCEDURE reagit ( CH : Char) ;        VIRTUAL ;
                        END ;

     pBoutonRadio = ^oBoutonRadio ;
     oBoutonRadio = OBJECT (objet)
                           etat   : Boolean ;
                           option : String  ;

                           CONSTRUCTOR init (posx, posy : Integer ;
                                             chaine : String;
                                             debut : Boolean ) ;
                           PROCEDURE reagit ( CH : Char ) ;          VIRTUAL ;
                           PROCEDURE redraw ;                        VIRTUAL ;
                    END ;

     pelement = ^telement ;
     telement = RECORD
                      elt  : pobjet   ;
                      suiv : pelement ;
                END ;


     pBureau = ^oBureau ;
     oBureau = OBJECT
                     courant,
                     liste : pelement ;

                     CONSTRUCTOR init ;
                     PROCEDURE ajoute (elt : pobjet) ;
                     PROCEDURE Exec ;
                     PROCEDURE redraw ;
                     PROCEDURE modifieCourant ;
                     PROCEDURE btg ;
                     DESTRUCTOR done ;
               END ;


     pGroupeCritere = ^oGroupeCritere ;
     oGroupeCritere = OBJECT (objet)
                             courant : Byte          ;
                             saisie  : psaisie       ;
                             critere : pcritere      ;
                             et      : pboutonradio  ;
                             ou      : pboutonradio  ;
                             non     : pboutoncocher ;

                             CONSTRUCTOR init (PosX, PosY : Integer;
                                               lien : pcritere ) ;
                             PROCEDURE reagit ( CH : Char) ;         VIRTUAL ;
                             PROCEDURE redraw ;                      VIRTUAL ;
                             DESTRUCTOR done ;                       VIRTUAL ;
                      END ;


{=============================================================================
                D E F I N I T I O N   D E S   O B J E T S
 ============================================================================}

{============================================================================}
{****************************** OBJET DE BASE *******************************}
{============================================================================}

VAR liste   : pListe     ; { La liste du bureau est globale pour que
                             les boutons puissent interagir avec elle. }


{============================ Gestion de la souris ==========================}

{ Je m'en rapelle plus ce qu'elle fait, ah c'est malin d'avoir mis de
  l'assembleur! On comprend plus rien, et puis niveau portabilité chapeau
  vraiment ça vaut bien le coup de payer à prix d'or (?) des enseignants qui
  forcent à programmer sous UNIX en C soit disant portable sur tout système!}
PROCEDURE HideMouse ; ASSEMBLER ;

ASM
   mov AX, 2
   Int 33h
END ;


{ Vraiment rien compris, il va falloir tout recommencer... }
PROCEDURE ShowMouse ; ASSEMBLER ;

ASM
   mov AX, 1
   Int 33h
END ;



{ Renvoie si l'on a appuyé sur un bouton de la souris, je pense.... }
FUNCTION boutonsouris : Boolean ; ASSEMBLER;

ASM
   mov AX, 3
   Int $33
   mov AX, BX { Alias Return(BX) :) }
END ;



{ Dessine un cadre simple en (x,y) avec une largeur l et une hauteur h. }
PROCEDURE cadre (X, Y, l, h : Integer ) ;

VAR i : Byte ;

BEGIN
     GotoXY (X + 1, Y) ;
     QWrite (Y, X, '┌');
     FOR i := 2 TO l
         DO
           Write ('─') ;
     Write ('┐') ;
     FOR i := 1 TO Pred (h)
         DO
           BEGIN
                QWrite (Y + i, X, '│');
                QWrite (Y + i, X + l, '│');
           END ;
     GotoXY (X + 1, Y + h) ;
     QWrite (Y + h, X, '└');
     FOR i := 2 TO l
         DO
           Write ('─') ;
     Write ('┘') ;
END ;



CONSTRUCTOR objet. init (posx, posy, largeur, hauteur : Integer) ;

BEGIN
     X := posx; Y := posy; l := largeur; h := hauteur ;
     etendu := FALSE ;    { Par défauts les codes étendus ne sont pas gérés. }
END ;


DESTRUCTOR objet. done ;

BEGIN { C'est tout?, ca valait bien le coup... Et les procédures abstraites }
END ; { ça existe en C++ alors, hein? }


PROCEDURE objet. redraw ;

BEGIN { Mon dieu quel gachis. }
END ;


PROCEDURE objet. reagit (CH : Char) ;

BEGIN { Ca se trimbale 128Mo de mémoire et 14Go de disque alors tout de
        suite on se laisse aller, et pourquoi pas des commentaires pour
        gonfler le source de façon artificiel de façon à dire:
        "Moi, j'ai codé un programmé qui faisait 2887 lignes..."
        P.S: Gloire aux aventuriers de tout poil qui vérifieront cette
             assertion... }
END ;


FUNCTION objet. focus : Boolean ;

VAR mx, my : Integer ;

BEGIN
     ASM
        @looop:
        mov AX , 3
        Int 33h
        cmp BX , 0   { Attente du bouton relaché.. }
        jne @looop
        SHR CX , 3   { Conversion des coordonnées souris en coordonnées }
        SHR DX , 3   { écran entre 1 et 80 et 1 et 25. }
        Inc CX
        Inc DX
        mov mx , CX  { Sauvegarde des résultats dans mx et my. }
        mov my , DX
     END ;

     focus := (mx <= X + l) AND (mx >= X) AND (my <= Y + h) AND (my >= Y) ;
END ;



{============================================================================}
{***************************** CHAMP DE SAISIE ******************************}
{============================================================================}

CONSTRUCTOR osaisie. init ( Posx, posy, max : Integer ) ;

BEGIN
     INHERITED init (posx, posy, max, 1) ;
     chaine := '' ;
     maxi := max ; { Nombre de caractères maximum. }
END ;



PROCEDURE osaisie. reagit (CH : Char) ;

BEGIN
     CASE  CH OF
      #8  : Delete (chaine, Length (chaine), 1) ; { BackSpace.    }
      #32..#250 : IF Length (chaine) < maxi       { Autre...      }
                    THEN
                        chaine := chaine + CH ;
     END ;
END ;



PROCEDURE osaisie. redraw ;

VAR i : Byte ;

BEGIN
     IF Souris
        THEN
            hidemouse ;
     cadre (X, Y, maxi + 2, 2) ;                  { On dessine le cadre.  }
     GotoXY (X + 1 + Length (chaine), Y + 1) ;
     QWrite (Y + 1, X + 1, chaine) ;              { On écrit la chaîne.   }
     FOR i := Length (chaine) TO maxi             { On efface ensuite.    }
         DO
           Write (' ') ;
     GotoXY (X + 1 + Length (chaine), Y + 1) ;    { Repositionnement à la }
     IF Souris                                    { fin de la chaîne.     }
        THEN
            ShowMouse ;
     ShowCursor ;
END ;



{============================================================================}
{***************************** BOUTON A COCHER ******************************}
{============================================================================}

CONSTRUCTOR oboutoncocher. init (posx, posy : Integer;
                                 chaine : String ; debut : Boolean ) ;

BEGIN
     option     := chaine ;
     etat       := debut  ;
     changement := FALSE  ;
     INHERITED init (posx, posy , Length (option) + 4, 0) ;
END ;



PROCEDURE oboutoncocher. redraw ;

BEGIN
     IF Souris
        THEN
            hidemouse ;
     HideCursor ;
     GotoXY (X, Y) ;
     Write ('[ ] ', option) ;
     IF etat
        THEN
            BEGIN
                 GotoXY (X + 1, Y) ;
                 Write ('X') ;
            END ;
     IF Souris
        THEN
            showmouse ;
END ;


PROCEDURE oboutoncocher. reagit (CH  : Char ) ;

BEGIN
     IF (CH = #32) OR (CH = #1)
        THEN
            BEGIN
                 changement := TRUE ;
                 etat := NOT (etat) ;
            END ;
END ;



{============================================================================}
{*********************************** LISTE **********************************}
{============================================================================}

CONSTRUCTOR oListe. init ( PosX, PosY, largeur, hauteur : Integer );

VAR temp : pfichier ;

BEGIN
     tete := NIL ;
     INHERITED init (PosX, PosY, largeur, hauteur) ;
     etendu  := TRUE ;
     courant := tete ;
     relatif := tete ;
END ;



{ Insère un élément dans la liste. }

PROCEDURE oListe. ajoute ( elt : pfichier ) ;

VAR temp : pelt ;

BEGIN
     IF tete = NIL
        THEN
            BEGIN
                 New (tete) ;
                 temp := tete ;
                 relatif := tete ;
                 courant := tete ;
            END
        ELSE
            BEGIN
                 temp := tete ;
                 WHILE temp^. suiv <> NIL
                       DO
                         temp := temp^. suiv ;
                 New (temp^. suiv) ;
                 temp := temp^. suiv ;
            END ;
     temp^. elt := elt ;
     temp^. suiv := NIL ;
END ;



{ Une procédure de 150 lignes et bien c'est du propre! }

PROCEDURE oListe. reagit ( CH : Char ) ;

VAR modif : Boolean ;
    temp  : pelt ;

 PROCEDURE haut ;

 BEGIN
      { Recherche du précédent de relatif. }
      IF relatif = tete
         THEN
             BEGIN
                  modif := FALSE ;
                  Exit ;
             END ;
      temp := tete ;
      WHILE temp^. suiv <> relatif
            DO
              temp := temp^. suiv;
      relatif := temp ;
      courant := relatif ;
 END ;

 PROCEDURE bas ;

 VAR i : Byte ;

 BEGIN
      { Recherche du suivant de relatif. }
      IF relatif^. suiv = NIL
         THEN
             BEGIN
                  modif := FALSE ;
                  Exit ;
             END ;
      temp := relatif^. suiv ;
      { On vérifie que la liste en-dessous est pleine. }
      i := 1 ;
      WHILE (i <> h - 1) AND (temp <> NIL)
            DO
              BEGIN
                   temp := temp^. suiv ;
                   Inc (i) ;
              END ;
      IF (temp <> NIL)
         THEN
             BEGIN
                  relatif := relatif^. suiv ;
                  courant := temp ;
             END
         ELSE
             modif := FALSE ;
 END ;


 PROCEDURE descend;

 BEGIN
      IF courant = queue
         THEN
             bas           { On est en bas de la liste. }
         ELSE
             courant := courant^. suiv ;
 END ;


 PROCEDURE monte ;

 BEGIN
      IF courant = relatif
         THEN
             haut          { On est en haut de la liste. }
         ELSE
             BEGIN
                  temp := tete ;
                  IF courant = tete
                     THEN
                         Exit ;
                  WHILE temp^. suiv <> courant
                        DO
                          temp := temp^. suiv ;
                  courant := temp ;
             END ;
 END ;


 PROCEDURE btg ;

  PROCEDURE element (nb : Byte ) ;

  VAR i    : Byte ;

  BEGIN
       { On cherche l'élément nb et l'on change son état, s'il existe. }
       temp := relatif ;
       i := 1 ;
       WHILE (i <> nb) AND (temp <> NIL)
             DO
               BEGIN
                    Inc (i) ;
                    temp := temp^. suiv ;
               END ;
       IF temp = NIL
          THEN
              BEGIN
                   modif := FALSE ;
                   Exit ;
              END ;
       courant := temp ;
       courant^. elt^. etat := NOT (courant^. elt^. etat );
  END ;


 VAR mx, my : Integer ;

 BEGIN
      { Récupération dans mx et my des coordonnées de la souris. }
      ASM
         mov AX, 3
         Int 33h
         SHR CX, 3
         SHR DX, 3
         Inc CX
         Inc DX
         mov mx, CX
         mov my, DX
      END ;
      { Clic sur l'une des flêches. }
      IF (mx = X + l) AND (my = Y + 1)
         THEN
             monte ;
      IF (mx = X + l) AND (my = Y + h - 1)
         THEN
             descend ;
      { Clic dans un élément de la liste. }
      IF (mx < X + l ) AND (mx > X ) AND (my > Y) AND (my < Y + h)
         THEN
             element (my - Y) ;
 END ;


BEGIN
     CASE CH OF
      #1  : btg ;                { Clic souris. }
      'P' : descend;             { Flêche bas.  }
      'H' : monte ;
      #32 : courant^. elt^. etat := NOT (courant^. elt^. etat) ;
     END ;
END ;


PROCEDURE oListe. redraw ;

VAR i, j : Byte ;
    temp : pelt ;
    old  : Byte ;

BEGIN
     HideCursor ;
     IF Souris
        THEN
            hidemouse ;
     cadre (X, Y, l, h) ;

     temp := relatif ;

     { On force la surintensité. }
     old := Lo (TextAttr) ;
     old := old AND $f ;

     i := 1 ;
     WHILE (i < h )
          DO
           BEGIN
                IF temp <> NIL THEN
                BEGIN
                     IF temp = courant
                        THEN
                            TextColor (LightRed) ;
                     IF temp^. elt^. etat
                        THEN
                            QWrite (Y + i, X + 1, ' √ ' + temp^. elt^. nom)
                        ELSE
                            QWrite (Y + i, X + 1, '   ' + temp^. elt^. nom) ;
                     TextColor (old) ;
                     GotoXY (X + 4 + Length (temp^. elt^. nom), Y + i) ;
                     FOR j := 1 TO l - 4 - Length (temp^. elt^. nom)
                         DO
                           Write (' ') ;
                     Write ('░') ;
                     queue := temp ;
                     temp := temp^. suiv ;
                     Inc (i) ;
                END
                ELSE
                BEGIN
                     FOR j := 1 TO l - 1 DO
                         QWrite (Y + i, X + j, ' ');
                     Inc (i) ;
                END ;
           END ;
     QWrite (Y + 1, X + l, '');
     QWrite (Y + h - 1, X + l, '');
     IF Souris
        THEN
            ShowMouse ;
END ;


DESTRUCTOR oListe. done ;

BEGIN
     courant := tete ;
     WHILE tete <> NIL
           DO
             BEGIN
                  courant := tete^. suiv ;
                  Dispose (tete );
                  tete := courant ;
             END ;
END ;




{============================================================================}
{******************************** BOUTON RADIO ******************************}
{============================================================================}

CONSTRUCTOR OBoutonRadio. init (posx, posy : Integer ; chaine : String;
                                debut : Boolean ) ;

BEGIN
     option     := chaine ;
     etat       := debut  ;
     changement := FALSE  ;
     INHERITED init (posx, posy , Length (option) + 4, 0) ;
END ;



PROCEDURE oBoutonRadio. reagit ( CH : Char ) ;

BEGIN
     CASE CH OF
      #0 : etat := TRUE ;  { On le force à vrai avec #0. }
      #1 : etat := FALSE ; { On le force à faux. }
      ELSE Exit ;          { On ignore tous les autres caractères. }
     END ;
     changement := TRUE ;
END ;



PROCEDURE oBoutonRadio. redraw ;

BEGIN
     IF Souris
        THEN
            hidemouse ;
     QWrite (Y, X, '( ) ' + option) ;
     IF etat
        THEN
            QWrite (Y, X + 1, #7);
     IF Souris
        THEN
            showmouse ;
END ;



{============================================================================}
{******************************** OBJET CRITERE *****************************}
{============================================================================}

CONSTRUCTOR oGroupeCritere. init (PosX, PosY : Integer; lien : pcritere) ;

BEGIN
     critere := lien ;
     courant := 4 ;
     saisie := New (psaisie, init (PosX, PosY + 1, 40) ) ;
     saisie^. chaine := lien^. champ ;
     non    := New (pboutoncocher, init (PosX, PosY, 'Non', FALSE) ) ;
     non^. etat := lien^. negation ;
     et     := New (pboutonradio, init (PosX + 17, PosY, 'Et', TRUE) ) ;
     et^. etat := (lien^. transition = 1) ;
     ou     := New (pboutonradio, init (PosX + 35, PosY, 'Ou', FALSE) ) ;
     ou^. etat := (lien^. transition = 1) ;
     INHERITED init (PosX, PosY, 40, 2) ;
END ;



PROCEDURE oGroupeCritere. reagit (CH: Char) ;

 PROCEDURE react ;

 BEGIN
      CASE courant OF
       1 : non^. reagit (CH) ;
       2 : BEGIN
                et^. reagit (#0) ; { Et vrai. }
                ou^. reagit (#1) ; { Ou faux. }
           END ;
       3 : BEGIN
                et^. reagit (#1) ; { l'inverse du dessus. }
                ou^. reagit (#0) ;
           END ;
       4 : saisie^. reagit (CH) ;
      END ;
      courant := 4 ;
 END ;


 PROCEDURE btg ;

 VAR temp : Byte ;

 BEGIN
      temp := courant ;
      courant := 0 ;
      { On cherche si on a cliqué sur un objet, si oui on modifie l'objet
        courant. }
      IF (non^. focus)
         THEN
             courant := 1 ;
      IF (et^. focus)
         THEN
             courant := 2 ;
      IF (ou^. focus)
         THEN
             courant := 3 ;
      IF (saisie^. focus)
         THEN
             courant := 4 ;
      { Si on a cliqué sur un objet du groupe critère. }
      IF (temp = courant) OR (courant <> 0)
         THEN
             BEGIN
                  CH := #1;
                  react ;
             END ;
 END ;


BEGIN
     CASE CH OF
      #1     : btg ;
      #32    : react ;
      Ctrl_N : BEGIN
                    Courant := 1 ;
                    CH := #32 ;  { Force le basculement de la case à cocher. }
                    react ;
               END ;
      Ctrl_E : BEGIN
                    Courant := 2 ;
                    react ;
               END ;
      Ctrl_O : BEGIN
                    Courant := 3 ;
                    react ;
               END ;
      ELSE
          IF courant = 4
             THEN
                 saisie^. reagit (CH)
             ELSE
                 Exit ;
     END ;
END ;



PROCEDURE oGroupeCritere. redraw ;

BEGIN
     ASM                               { On sauvegarde les attributs sur la }
        mov AL, TextAttr               { pile ca évite de déclarer une      }
        push AX                        { variable temporaire....            }
     END ;
     TextColor (7) ;                   { On grise les autres champs.        }
     non^. redraw ;
     et^. redraw ;
     ou^. redraw ;
     saisie^. redraw ;
     ASM                               { On récupère l'ancien attribut.     }
        pop AX
        mov TextAttr, AL
     END ;
     IF (TextAttr AND $f) = 07         { Si la couleur était gris clair.    }
        THEN
            Exit ;                     { alors on sort sans activer le champ}
     TextColor (15) ;                  { On active le champ courant.        }
     CASE courant OF
      1 : non^. redraw ;
      2 : et^. redraw ;
      3 : ou^. redraw ;
      4 : saisie^. redraw ;
     END ;
     critere^. negation := non^. etat ; { On récupère le contenu des champs. }
     critere^. champ := saisie^. chaine ;
     IF et^. etat
        THEN
            critere^. transition := 1
        ELSE
            critere^. transition := 2 ;
END ;



DESTRUCTOR oGroupeCritere. done ;

BEGIN
     Dispose (saisie, done) ;
     Dispose (ou, done) ;
     Dispose (et, done) ;
     Dispose (non, done) ;
END ;




{============================================================================}
{******************************** OBJET BUREAU ******************************}
{============================================================================}

CONSTRUCTOR oBureau. init ;

BEGIN
     liste := NIL ;
     courant := NIL ;
END ;



PROCEDURE oBureau. ajoute (elt : pobjet) ;

BEGIN
     IF liste = NIL
        THEN
            BEGIN
                 New (liste) ;
                 courant := liste ;
            END
        ELSE
            BEGIN
                 courant := liste ;
                 WHILE (courant^. suiv <> NIL)
                       DO
                         courant := courant^. suiv ;
                 New (courant^. suiv ) ;
                 courant := courant^. suiv ;
            END ;
     courant^. elt := elt ;
     courant^. suiv := NIL ;
END ;



PROCEDURE oBureau. Exec ;

VAR CH   : Char     ;
    fini : Boolean  ;
    temp2,
    temp : pelement ;

 PROCEDURE attente_evenement ;

 BEGIN
     IF Souris
        THEN
            REPEAT
            UNTIL (KeyPressed) OR (boutonsouris)
        ELSE
            REPEAT
            UNTIL (KeyPressed) ;
      IF KeyPressed
         THEN
             CH := ReadKey
         ELSE
             CH := #1 ;
 END ;


BEGIN
     fini := FALSE ;
     courant := liste ;
     redraw ;
     IF Souris
        THEN
            BEGIN
                 ASM
                    mov AX, 0
                    Int 33h
                 END ;
                 ShowMouse ;
            END ;

     WHILE NOT (fini)
           DO
             BEGIN
                  temp := courant ;
                  attente_evenement ;
                  CASE CH OF
                  #9  : IF courant^. suiv <> NIL { Tab }
                           THEN
                               courant := courant^. suiv
                           ELSE
                               courant := liste ;
                  #27 : BEGIN
                             esc  := FALSE ;
                             fini := TRUE ;
                        END ;
                  #13 : fini := TRUE ; { Return }
                  #0  : BEGIN
                             CH := ReadKey ;
                             CASE CH OF
                              #15 :{ Shift-Tab }
                                    BEGIN
                                         IF courant = liste
                                            THEN
                                                courant := NIL ;
                                         temp2 := liste ;
                                         WHILE temp2^. suiv <> courant
                                               DO
                                                 temp2 := temp2^. suiv ;
                                         courant := temp2 ;
                                    END ;
                              ELSE
                                  IF courant^. elt^. etendu
                                     THEN
                                         BEGIN
                                              courant^. elt^. reagit (CH) ;
                                              courant^. elt^. redraw ;
                                         END ;
                             END ;
                        END ;
                  #14 : BEGIN
                             CH := Ctrl_N ;
                             courant^. elt^. reagit (CH) ;
                             courant^. elt^. redraw ;
                        END ;
                  #15 : BEGIN
                             CH := Ctrl_O ;
                             courant^. elt^. reagit (CH) ;
                             courant^. elt^. redraw ;
                        END ;
                  #5 : BEGIN
                            CH := Ctrl_E ;
                            courant^. elt^. reagit (CH) ;
                            courant^. elt^. redraw ;
                       END ;
                  #1  : BEGIN
                             btg ;
                             courant^. elt^. redraw ;
                        END ;
                  ELSE
                      BEGIN
                           courant^. elt^. reagit (CH) ;
                           courant^. elt^. redraw ;
                      END ;
                  END ;
                  IF temp <> courant
                     THEN
                         BEGIN
                              TextColor (7) ;
                              temp^. elt^. redraw ;
                              TextColor (15) ;
                              courant^. elt^. redraw ;
                         END ;
             END ;
END ;



PROCEDURE oBureau. redraw ;

VAR temp : pelement ;

BEGIN
     temp := liste ;
     ASM
        { Wait For Retrace }
        MOV DX, $3DA
        @RT:
        IN AL, DX
        Test AL, 8
        JZ @RT
     END ;
     WHILE temp <> NIL
           DO
             BEGIN
                  TextColor (7) ;
                  temp^. elt^. redraw ;
                  temp := temp^. suiv ;
             END ;
     TextColor (15) ;
     courant^. elt^. redraw ;
END ;



PROCEDURE oBureau. modifieCourant ;

VAR temp : pelement ;

BEGIN
     { On cherche l'élément sélectionné à la souris. }
     temp := liste ;
     WHILE (temp <> NIL) AND (NOT temp^. Elt^. focus)
           DO
             temp := temp^. suiv ;

     { Si aucun n'est sélectionné alors on quitte. }
     IF temp = NIL
        THEN
            Exit ;

     courant := temp ;
     courant^. elt^. reagit (#1) ;
END ;



PROCEDURE oBureau. btg ;

BEGIN
     IF courant^. elt^. focus
        THEN
            courant^. elt^. reagit (#1)
        ELSE
            ModifieCourant ;
END ;



DESTRUCTOR oBureau. done ;

BEGIN
     courant := liste ;
     WHILE liste <> NIL
           DO
             BEGIN
                  liste := courant^. suiv ;
                  Dispose (courant^. elt, done) ;
                  Dispose (courant) ;
                  courant := liste ;
             END ;
END ;


{============================================================================}
{**************************** OBJET BoutonCocherBis *************************}
{============================================================================}

PROCEDURE OBoutonCocherBis. reagit (CH : Char) ;

BEGIN
     INHERITED reagit (CH) ;
     IF changement
        THEN
            BEGIN
                 bascule (num, etat) ;
                 TextColor (7) ;
                 liste^. redraw ; { Mise à jour de l'affichage de la liste. }
                 TextColor (15) ;
            END ;
END ;