Les fiches

Jean-Michel Doudoux

- Titre : Les fiches

- Auteur : Jean-Michel Doudoux

- Parution : 6 novembre 2003

- Mise à jour : 24 décembre 2019

- Licence : Copyright ® 2003 J.M.Doudoux. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Les fiches sont des objets de la classe TForm

- I-A. Les propriétés d'une fiche

- I-B. Les méthodes des fiches

- I-C. Les événements d'une fiche

- I-C-1. Les événements associés à la souris

- I-C-2. Les événements clavier

- I-D. La fermeture d'une fiche

- I-E. Activation et focus

- I-E-1. Le focus

- I-E-2. L'ordre de tabulation

- I-E-3. Les propriétés associées au focus

- I-E-4. Les méthodes associées au focus

- II. Les fenêtres MDI (Multiple Document Interface)

- II-A. Le style d'une fenêtre MDI

- II-B. La gestion des fiches MDI filles

- II-C. Les menus des fenêtres MDI

- II-D. La présentation en mosaïque

- II-E. La présentation en cascade

- II-F. La réorganisation des icônes

- II-G. L'activation des fiches MDI filles

- III. L'affichage d'une boite de dialogue

I - Les fiches sont des objets de la classe TForm

Les fenêtres sont des objets de la classe TForm qui représente une fenêtre. En tant qu'objets, les fiches disposent de propriétés qui les caractérisent et de méthodes pour les manipuler. Elles permettent aussi de gérer un certain nombre d'événements susceptibles de se produire.

I-A - Les propriétés d'une fiche

Nom

Description

BorderIcons

spécifie les différentes icônes apparaissant dans la barre de titre en valorisant cette propriété avec les valeurs suivantes :

- biSystemMenu (menu système) ;

- biMinimize (bouton réduction) ;

- biMaximize (bouton agrandissement).

BorderIcons := [biSystemMenu, biMinimize, biMaximize];
BorderIcons := []; (* pour supprimer toutes les icônes*)

BorderStyle

donne un aspect particulier à la bordure de la fenêtre suivant les valeurs :

- bsDialog : bordure simple, non redimensionnable ;

- bsNone : aucune bordure donc aucune icône dans la barre de titre, impossible de déplacer la fenêtre ;

- bsSingle : bordure simple non redimensionnable ;

- bsSizeable : bordure double, la fiche est redimensionnable.

Caption

titre de la fenêtre qui s'utilise en lecture ou écriture.

WindowState

définit l'état de la fenêtre suivant les valeurs :

- wsNormal : affichage normal ;

- wsMaximized : affichage de la fenêtre en plein écran ;

- wsMinimized : affichage sous forme d'icône.

Cursor

définit l'image du curseur de la souris lorsqu'il se trouve sur la zone client :

- crDefault : curseur par défaut ;

- crArrow : flèche ;

- crCross : croix simple ;

- crIBeam : curseur en forme de I majuscule ;

- crSize : croix formée de deux doubles flèches

- crSizeNESW : flèche nord-est / sud-ouest ;

- crSizeNS : flèche nord-sud. crSizeNWSE : flèche nord-ouest / sud-est ;

- crSizeWE : flèche est / ouest ;

- crUpArrow : flèche large orientée vers le haut. crHourglass : sablier ;

- crNoDrop : panneau d'interdiction utilisé pour les opérations de glisser-déposer ;

- crHSplit : séparation horizontale ;

- crVSplit : séparation verticale.

Height

hauteur de la fenêtre.

Width

largeur de la fenêtre.

ClientHeight

hauteur de la zone client.

ClientWidth

largeur de la zone client.

Position

détermine la position de la fenêtre suivant les valeurs suivantes :

- poDesigned : position identique à celle de la conception ;

- poDefault : coordonnée et taille de la fenêtre sont déterminées automatiquement ;

- poDefaultPosOnly : taille de la conception avec position déterminée par Delphi ;

- poDefaultSizeOnly : position de la conception avec taille déterminée par Delphi ;

- poScreenCenter : la fenêtre est positionnée au centre de l'écran.

modalResult

une valeur différente de 0 ferme une fenêtre ouverte de façon modale. La valeur prise par la propriété lors de la fermeture de la fenêtre est retournée par la fonction ShowModal, ce qui permet de l'analyser depuis la fonction appelante. La liste des constantes prédéfinies suivantes peut être employée avec la propriété modalResult :

- mrNone (0) : la fenêtre reste ouverte ;

- mrOk idOk (1) : valider ;

- mrCancel idCancel (2) : annuler ;

- mrAbort idAbort(3) : abandonner ;

- mrRetry idRetry (4) : réessayer ;

- mrIgnore idIgnore (5) : ignorer ;

- mrYes idYes () : Oui ;

- mrNo idNo () : Non ;

- mrAll mrNo + 1: Autre.

D'autres constantes peuvent être définies par le programmeur afin de traiter d'autres situations particulières associées à la fermeture d'une fenêtre.
La fermeture par le menu système (option fermeture) ou bien par la combinaison des touches Alt F4 est équivalente à l'affectation de la valeur mrCancel à modalResult.
Exemple de code pour analyser la valeur retournée par ShowModal :

i := formfenetre.showmodal;
case i of
mrNone : ..
mrYes : ...
end;

Remarque : les composants TButton et TBitBtn possèdent également une propriété modalResult. Celle-ci s'utilise de la même façon que TForm.modalResult pour fermer une fenêtre modale.

I-B - Les méthodes des fiches

Voici quelques-unes des principales méthodes des fiches

Nom

Description

SetBounds

modifie les coordonnées et la taille de la fenêtre

SetBounds(aleft, atop, awidth, aheight)

Cette méthode effectue les modifications en une seule fois et permet de supprimer les réaffichages intermédiaires.

Show

permet de mettre la propriété Visible à True et tente de positionner la fenêtre au premier plan.

Close

permet de fermer la fenêtre. Si la fenêtre est déjà fermée, cette méthode n'a aucun effet.

ShowModal

permet l'ouverture de la fenêtre de façon modale. Pour fermer une fenêtre modale à l'aide du langage de programmation, il faut utiliser la propriété modalResult.

Hide

cacher une fiche. Une fiche cachée sera rendue à nouveau visible en exécutant la méthode Show.

I-C - Les événements d'une fiche

Une grande partie du code source d'une application est écrite pour répondre à des événements.

La liste des événements d'une fiche apparaît dans le volet événement de la fenêtre de l'inspecteur d'objets. Si le nom saisi ne correspond à aucune méthode existante, le gestionnaire d'événement est automatiquement créé : son entête est ajouté à la liste des méthodes de la classe TForm et un squelette de définition est inséré dans la partie implémentation de l'unité.

Attention : si une procédure événement est déclarée sans qu'aucune ligne de code particulière n'y figure, Delphi en supprimera toute trace lors de la prochaine sauvegarde du fichier.

Rien n'empêche d'utiliser un même gestionnaire d'événement pour plusieurs événements, c'est-à-dire, d'utiliser une même méthode pour traiter des événements d'origines différentes. Il est donc possible de définir une méthode générique applicable à n'importe quel composant. Il est également possible d'utiliser un même gestionnaire d'événement pour traiter des événements de natures différentes, associés à des composants également différents. Il suffit d'utiliser un gestionnaire d'événement correspondant à un type procédural identique ou compatible. Ainsi les événements distincts OnClick et OnDblClick appartiennent au même type TNotifyEvent. C'est pourquoi on peut affecter à ces propriétés une même procédure, répondant au modèle suivant :

Composant.UneMethode(Sender : TObject);

Lorsque l'on opère de cette façon, il devient nécessaire de pouvoir déterminer le composant exact qui a généré l'événement. C'est le paramètre Sender de la méthode événement qui permet cela puisqu'il s'agit d'un héritier d'une classe TObject. Il contient les informations nécessaires pour l'identifier. On utilise notamment les méthodes ClassType et ClassName pour connaitre le type et le nom de la classe du composant concerné par l'événement.

Exemple :

var
f : TForm;
b : TButton ;
begin
(* teste si l'objet reçu est une fiche *)
if Sender.ClassType = TFrom1 then
begin
f := Sender as TForm;
(* pratiquement équivalent au transtypage f := TForm1(Sender) *)
end;

(* teste si l'objet reçu est un bouton*)
if Sender.ClassType = TButton then
begin
b:=TButton(Sender);
b.Caption:='Click';
end;
end;

I-C-1 - Les événements associés à la souris

- OnClick désigne un événement de type TNotifyEvent qui représente la forme la plus simple des événements, défini dans l'unité Classes. TNotifyEvent est le type des événements sans paramètre, et dont la seule fonction est d'indiquer à un composant qu'un événement s'est produit, par exemple un clic de souris. D'autres actions de l'utilisateur peuvent d'ailleurs provoquer la génération d'un événement OnClick :

- la sélection d'une cellule d'une grille, d'un contrôle outline, d'une liste simple ou combinée par utilisation d'une touche flèche haut ou bas ;

- l'appui sur la barre d'espace lorsque le focus se trouve dans un bouton ou une case à cocher ;

- l'appui sur la touche Entrée lorsqu'une fiche active contient un bouton par défaut ;

- l'utilisation d'une touche d'accès rapide ;

- etc.

- OnDblClick est généré lors d'un double clic.

- OnMouseDown est généré lors de l'appui sur un bouton de la souris.

- OnMouseUp est généré lors du relâchement de ce bouton.

Les propriétés événements correspondantes possèdent le type TMouseEvent

TMouseEvent = Procedure(Sender : TObject ; Button : TMouseButton ; Shift : TShiftState ; X , Y : Integer) of object;

L'argument Sender est associé au composant ayant généré l'événement. L'argument Button se réfère au bouton ayant été utilisé. Ce paramètre est un type énuméré, défini comme ceci :

TMouseButton = ( mbRight, mbLeft , mbCenter);

La valeur mbRight désigne le bouton droit, mbLeft le bouton gauche et mbCenter le bouton du milieu lorsqu'il existe.

Le troisième paramètre, de type TShiftState, permet de savoir si une touche de contrôle (ALT, CTRL ou MAJ) était maintenue enfoncée lorsque l'événement souris est survenu.

TShiftState est défini comme un ensemble basé sur une énumération :

TShiftState = set of (ssShift, ssAlt, ssCtrl, ssLeft, ssRight, ssMiddle, ssDouble);

- ssShift la touche MAJ est maintenue enfoncée.

- ssAlt la touche ALT est maintenue enfoncée.

- ssControl la touche CTRL est maintenue enfoncée.

- ssLeft le bouton gauche de la souris est maintenu enfoncé.

- ssRight le bouton droit de la souris est maintenu enfoncé.

- ssMiddle le bouton gauche de la souris est maintenu enfoncé.

- ssDouble les boutons gauche et droit de la souris sont maintenus appuyés.

Les arguments X et Y reçus par les procédures de types TMouseEvent permettent de connaitre la position du curseur lorsque l'utilisateur a appuyé ou relâché le bouton de la souris. Les coordonnées sont exprimées en pixels.

- OnMouseMove est généré lorsque le curseur de la souris est déplacé dans la partie visible d'un composant. Le type de cette propriété est TMouseMoveEvent

TMouseMoveEvent = procedure(Sender : TObject; TShift : TShiftState; X, Y : Integer) of objet;

Exemple : afficher les coordonnées du curseur dans une barre de titre

procedure Tfsouris.FormMouseEvent(Sender:TObject ; Shift : TShiftState ; X,Y : Integer);
begin
caption:=IntToStr(X) + ' : ' + IntToStr(Y);
end;

I-C-2 - Les événements clavier

Il existe trois événements associés à la gestion de l'utilisation du clavier.

- OnKeyDown est généré par le composant ayant le focus lorsque l'utilisateur appuie sur une touche du clavier. Il appartient à un type particulier appelé TKeyEvent. Ce type est défini dans l'unité Controls comme ceci :

TKeyEvent = procedure(Sender : TObject ; var key : Word ; Shift : TShiftState) of object;

Sender contient le composant associé à cet événement. key contient le code virtuel de la touche du clavier. Liste des codes de touches virtuels utilisés par Windows :

- VK_LBUTTON bouton gauche de la souris ;

- VK_RBUTTON bouton droit de la souris ;

- VK_MBUTTON bouton central de la souris ;

- VK_CANCEL arrêt de l'exécution d'un programme ;

- VK_BACK retour arrière ;

- VK_TAB tabulation ;

- VK_RETURN entrée ;

- VK_SHIFT touche de contrôle MAJ ;

- VK_CONTROL touche de contrôle CTRL ;

- VK_MENU touche de contrôle ALT ;

- VK_PAUSE pause ;

- VK_ESCAPE échappement ;

- VK_SPACE espace ;

- VK_PRIOR page haut ;

- VK_NEXT page bas ;

- VK_END fin ;

- VK_HOME début ;

- VK_LEFT flèche gauche ;

- VK_UP flèche haut ;

- VK_RIGHT flèche droite ;

- VK_DOWN flèche bas ;

- VK_SNAPSHOT impression d'écran ;

- VK_INSERT insérer ;

- VK_DELETE supprimer ;

- VK_HELP aide ;

- VK_NUMPAD0 touche 0 (pavé numérique) ;

- … …

- VK_NUMPAD9 touche 9 (pavé numérique) ;

- VK_MULTIPLY multiplication (pavé numérique) ;

- VK_ADD addition (pavé numérique) ;

- VK_SEPARATOR entrée (pavé numérique) ;

- VK_SUBTRACT soustraction (pavé numérique) ;

- VK_DECIMAL point décimal (pavé numérique) ;

- VK_DIVIDE division (pavé numérique) ;

- VK_F1 touche de fonction F1 ;

- … …

- VK_F24 touche de fonction F24 ;

- VK_NUMLOCK verrouillage du pavé numérique ;

- VK_SCROLL verrouillage défilement écran ;

- VK_CAPITAL verrouillage majuscules ;

TShiftState permet de détecter l'utilisation des touches de contrôle ainsi que les boutons de la souris.

OnKeyUp est généré lorsque cette touche est relâchée.

Exemple :

procedure paffichetouches(f : TfClavier; const MesUpDown : string ; var key : word)
begin
case key of
VK_LBUTTON : writeln('bouton gauche de la souris');
...
else
writeln(chr(key));
end;
f.setFocus;
end;

procedure TfClavier.FormKeyDown(Sender : TObject ; var key : Word ; Shift : TShiftState);
begin
paffichetouches(self,'(down)',key);
end;

procedure TfClavier.FormKeyUp(Sender : TObject ; var key : Word ; Shift : TShiftState);
begin
paffichetouches(self,'(up)',key);
end;

Les événements OnKeyDown et OnKeyUp sont particulièrement adaptés à la capture des touches du clavier correspondant à des codes non imprimables.

OnKeyPress : l'appui et le relâchement des touches ne sont pas distingués. Le type de OnKeyPress est TKeyPressEvent :

TKeyPressEvent = procedure(Sender : Tobject ; var Key : Char ) of Object ;

Remarque : l'ordre de génération des événements est : KeyDown, puis KeyPress et enfin KeyUp.

L'interception des touches par la fiche

L'événement clavier est normalement adressé au contrôle de la fiche (celui possédant le focus). La procédure booléenne KeyPreview permet l'interception des événements clavier par la fiche, sous réserve que les propriétés OnKeyPress, OnKeyDown ou OnKeyUp ne soient pas toutes vides. Lorsque KeyPreview est à True, les méthodes associées aux événements clavier appartenant à la fiche sont déclenchées avant les méthodes correspondantes des composants de la fiche.

Le plus grand intérêt de KeyPreview est la possibilité d'effectuer un traitement global des événements clavier, par exemple les touches de fonctions dans un masque de saisie.

C'est également au niveau de la fiche qu'il est possible d'interpréter, mais aussi de convertir les informations du clavier dans la mesure où le paramètre Key est passé par référence, ce qui implique que toute modification sur sa valeur sera conservée et répercutée dans les procédures de gestion des événements suivantes.

L'exemple le plus simple est la mise en majuscules de tous les caractères tapés au clavier en une seule routine au niveau de la fiche, plutôt que de répéter les mêmes instructions au niveau de chaque contrôle :

procedure TForm1.FormKeyPress(Sender : TObject ; var Key : Char);
begin
key:=UpCase(Key);
end;

I-D - La fermeture d'une fiche

La fermeture de la fenêtre s'effectue soit interactivement par l'utilisation du menu système ou par Alt+F4 soit au niveau de la programmation par la méthode Close. Cette action est associée à la génération d'un événement OnClose, de type TCloseEvent. Ce type est défini de la façon suivante :

TCloseEvent=procedure(Sender : TObject; var Action : TCloseAction) of object;

Action fait appel au type TCloseAction acceptant les valeurs prédéfinies suivantes :

- caFree : la fiche est détruite et la mémoire affectée est libérée ;

- caHide : la fiche n'est pas détruite, mais simplement cachée (Visible=False) ;

- caMinimize : la fiche n'est pas fermée, mais simplement réduite en icône : c'est l'action par défaut des fenêtres enfants MDI ;

- caNone : la fiche ne peut pas être fermée et rien ne se produit.

L'interception de l'événement OnClose est utile pour placer des demandes de confirmation.

La demande de fermeture d'une fiche

Proche de l'événement OnClose, l'événement OnCloseQuery est lié à la survenue d'une demande de fermeture de la fiche par l'utilisateur ou le programme.

OnCloseQuery appartient au type TCloseQueryEvent défini de la façon suivante :

TCloseQueryEvent = procedure(Sender : TObject; var CanClose : Boolean) of object;

C'est par la valeur affectée à l'argument booléen CanClose qu'est indiquée l'autorisation ou l'interdiction de fermeture de la fenêtre. Lors d'une demande de fermeture, l'événement OnClose est exécuté et elle exécute elle-même la méthode CloseQuery pour savoir si la fenêtre peut être fermée. Cette méthode est une fonction retournant un booléen. Lorsque la valeur True est retournée, l'événement OnCloseQuery est généré, permettant au programmeur d'intervenir sur le déroulement de la fermeture en donnant une valeur à CanClose. Si l'autorisation de fermeture est donnée, Close tente de fermer la fiche en générant un événement OnClose. À nouveau le processus peut être interrompu ou détourné par l'indication d'une valeur à l'argument Action.

I-E - Activation et focus

Les objets Application et les fiches possèdent chacun des événements OnActivate et OnDeactivate, générés respectivement lorsqu'un composant devient actif ou inactif.

I-E-1 - Le focus

Avoir le focus à un moment donné signifie pour un composant qu'il est l'élément actif.

Les fiches possèdent une méthode Focused, de type fonction, retournant une valeur booléenne indiquant si la fiche est active. Les objets TForm possèdent également une propriété permettant de déterminer le contrôle actif à un moment donné. Il s'agit de ActiveControl, qui contient une donnée de type TWinControl.

La classe TWinControl représente en effet les contrôles fenêtrés et donc susceptibles de recevoir le focus.

La propriété booléenne Visible, appartenant à tous les contrôles ainsi qu'aux composants TControlScrollBar et TMenuItem doit être positionnée à True pour que l'élément apparaisse à l'écran et qu'il soit activable.

La valeur de la propriété Enabled détermine si l'objet peut être activable.

I-E-2 - L'ordre de tabulation

L'ordre de tabulation désigne l'ordre dans lequel le focus se déplace lorsque l'utilisateur fait usage de la touche de tabulation. Cet ordre de tabulation correspond par défaut à l'ordre de création. Il peut être visualisé et modifié grâce à la boite de dialogue Modification Ordre de Tabulation. Elle est accessible à partir du menu déroulant de tous les éléments visuels d'une fiche, en sélectionnant l'option de menu Ordre de Tabulation.

I-E-3 - Les propriétés associées au focus

L'ordre de tabulation peut aussi être modifié par l'intermédiaire d'une propriété appelée TabOrder correspondant à un entier pouvant prendre la valeur allant de -1 à 32767.

Pour agir sur la possibilité qu'a un contrôle de recevoir le focus par tabulation, il faut utiliser la propriété booléenne TabStop. Lorsque TabStop est positionnée à False, il devient impossible de rendre actif le contrôle concerné par la touche de tabulation, bien que le contrôle reste activable, à l'aide de la souris par exemple.

I-E-4 - Les méthodes associées au focus

La méthode CanFocus appartenant à l'ensemble des contrôles fenêtrés détermine si le composant peut recevoir le focus :

Canfocus : Boolean;

Pour recevoir le focus, il est nécessaire que le contrôle concerné ainsi que ses conteneurs soient visibles et activables, en d'autres termes, que leurs propriétés Visible et Enabled soient à True.

La méthode SetFocus, sans paramètre, permet de donner le focus au composant concerné.

L'activation d'un composant est signalée par l'occurrence d'un événement OnEnter, du type procédural TNotifyEvent. Le départ du focus génère un événement OnExit.

II - Les fenêtres MDI (Multiple Document Interface)

Une fenêtre MDI est une fiche dont la particularité est qu'elle peut contenir d'autres fiches, appelées fenêtres MDI filles. Une application MDI permet de visualiser simultanément plusieurs documents, et éventuellement d'échanger des données entre eux dans un espace de travail commun.

II-A - Le style d'une fenêtre MDI

Du point de vue de la conception, les deux types de fiches (MDI mère et fille, appelées également MDI parent et MDI enfant) se distinguent par leur propriété FormStyle, dont le type est défini par une énumération des quatre valeurs suivante :

- fsMDIChild fenêtre MDI fille ;

- fsMDIForm fenêtre MDI mère ;

- fsNormal fenêtre non MDI ;

- fsStayOnTop le fenêtre reste toujours en avant-plan.

La fiche MDI mère doit être la fiche principale de l'application et est par conséquent unique. Par ailleurs, il est recommandé de ne pas déclarer les fiches filles dans la liste des fiches autocréées de la boite de dialogue Option de Projet (volet fiche), mais dans la liste des fiches disponibles, c'est-à-dire dont la création incombe au programmeur.

Les fiches MDI filles sont conçues indépendamment de la fiche mère, mais elles apparaissent lors de l'exécution toujours à l'intérieur de la fiche MDI et ne pourront jamais sortir de son cadre lors de l'exécution du programme. On ne peut créer qu'une seule fiche MDI mère par application, mais il peut exister plusieurs types différents de fiches MDI filles contenues dans une même fiche mère.

La démarche consiste à définir un modèle de fenêtre enfant, et de créer dynamiquement une ou plusieurs instances de cette fiche au cours de l'exécution du programme.

II-B - La gestion des fiches MDI filles

La détection de la fenêtre enfant active en cours d'exécution s'effectue à l'aide de la propriété ActiveMDIChild qui contient une référence de fiche.

Par exemple pour synchroniser le libellé de la barre de titre de la fiche mère avec celui de la fiche active :

Caption:=ActiveMDIChild.Caption

Le nombre de fiches enfants actuellement présentes dans la fiche parent est indiqué dans la propriété MDIChildCount, de type integer. Cette valeur correspond au nombre d'éléments du tableau MDIChildren qui contient les références de toutes les fenêtres enfants de l'application.

MDIChildren[I:integer] : TForm;

La valeur d'index utilisable dans ce tableau peut varier de 0 à MDIChildCount-1.

Exemple : réduction de toutes les fenêtres filles de l'application

for i := MDIChildCount - 1 downto 0 do MDIChildren[i].WindowState := wsMinimized;

II-C - Les menus des fenêtres MDI

Il existe plusieurs solutions pour faire apparaître des menus spécifiques à un document enfant, lorsqu'il devient actif, dans la barre des menus de la fiche MDI parent.

On peut créer tous les menus nécessaires dans la fiche mère et rendre certains menus visibles ou invisibles selon la présence ou non d'au moins une fiche fille Cela convient plus particulièrement quand il n'existe qu'un seul modèle de fiche fille. Par exemple, pour ne faire apparaître l'option édition de la barre principale de menu, appelée ici mnuEdition, que lorsqu'au moins une fenêtre MDI fille est présente dans l'application, utilisez l'instruction suivante :

mnuEdition.visible:=MDIChildCount > 0;

La deuxième solution consiste à créer les menus spécifiques dans les fiches et à fusionner les menus des fiches mère et filles lors de l'ouverture de la fille. La technique de la fusion des menus s'appuie sur les propriétés AutoMerge et GroupIndex des options menus.

Enfin, on peut également définir plusieurs menus principaux, avec des options adaptées à chacun des modèles de fiche enfant, et associer un menu à la fiche selon le contexte en valorisant différemment la propriété Menu par programmation, selon le principe suivant :

if MDIChildCount > 0 then menu:=mnu1 else menu:=mn2;

Les applications MDI possèdent souvent la liste des fenêtres filles ouvertes dans l'un des menus, généralement le menu fichier ou fenêtre. Pour obtenir cette gestion de liste automatiquement dans une application MDI Delphi, déclarez l'une des options de menu de la barre principale des menus dans la propriété WindowMenu. À l'exécution du programme, la liste des documents ouverts apparaît automatiquement au-dessous du dernier élément de l'option de menu indiqué. La fenêtre MDI fille active (c'est-à-dire la fiche ActiveMDIChild) apparaît dans la liste avec une marque de sélection.

Attention : il ne peut y avoir qu'une seule liste des documents MDI par barre de menus.

La liste des documents ouverts s'accompagne généralement d'un ensemble de commandes permettant la réorganisation de ces fenêtres. Les applications MDI doivent en effet inclure des options de menu contenant les commandes Mosaique, Cascade et Réorganiser les icônes afin que les utilisateurs puissent modifier la disposition de leurs documents ouverts dans la zone client de la fenêtre cadre.

II-D - La présentation en mosaïque

La méthode Tile réorganise l'ensemble des documents de telle manière que chacun d'eux possède la même taille et que l'ensemble des fenêtres MDI filles occupe la totalité de la zone client de la fenêtre MDI mère. Tile ne s'utilise que dans la fenêtre MDI mère, et ne reçoit aucun argument. La disposition exacte des documents dépend en fait de la valeur de la propriété TileMode, suivant les valeurs :

- tbHorizontal : chacune des fiches occupe la totalité de la largeur de la zone client de la fiche MDI mère ;

- tbVertical : chacune des fiches occupe la totalité de la hauteur de la zone client de la fiche MDI mère.

Attention : la définition de la propriété TileMode n'a de sens que pour une fiche MDI parent.

Si vous souhaitez modifier le comportement par défaut de Tile, insérez une instruction modifiant la valeur de TileMode

TileMode:=tbVertical;
Tile;

II-E - La présentation en cascade

La méthode Cascade dispose les fenêtres MDI filles de telle sorte qu'elles se recouvrent partiellement, le haut de chacun des documents restant visible afin de pouvoir le sélectionner.

Attention : la méthode Cascade, comme Tile, ne s'applique que pour la fenêtre MDI mère.

II-F - La réorganisation des icônes

La méthode ArrangeIcons appartient au même groupe que Tile ou Cascade, mais n'agit que sur les documents réduits en icône en réorganisant leur présentation en bas à gauche de la zone client de la fenêtre MDI mère. Exemple :

ArrangeIcons;

II-G - L'activation des fiches MDI filles

Les méthodes Next et Previous permettent d'activer respectivement la fiche MDI fille suivante et le fiche MDI fille précédente, par rapport à la séquence de l'ensemble des documents ouverts.

III - L'affichage d'une boite de dialogue

L'unité Dialogs propose plusieurs routines comprenant les fonctions InputBox, MessageDlg, MessageDlgPos et les procédures ShowMessage et ShowMessagePos. On trouve également la méthode MessageBox appartenant à l'objet TApplication.

La fonction MessageDlg permet d'afficher une boite de message centrée sur l'écran et contenant un libellé adressé à l'utilisateur :

MessageDlg(const Msg : string ; AType : TMsgDlgType ;AButtons : TMsgDlgButtons ;HelpCtx : Longint ) : Word ;

Msg est une chaine de caractères entourée par des apostrophes qui contient le texte du message. Le paramètre Atype est un type énuméré qui permet de préciser le style de la boite de dialogue. Il existe cinq valeurs :

- mtWarning : boite de message avec un point d'exclamation ;

- mtError : boite de message avec une main ;

- mtInformation : boite de message avec le caractère « i » ;

- mtConfirmation : boite de message avec un point d'interrogation ;

- mtCustom : boite de message ne contenant pas d'image.

Le paramètre AButtons spécifie la forme et le libellé de boutons devant apparaître dans la boite de message :

- mbYes : bouton Oui ;

- mbNo : bouton Non ;

- mbOk : bouton OK ;

- mbCancel : bouton Annuler ;

- mbHelp : bouton Aide ;

- mbAbort : bouton Abandonner ;

- mbRetry : bouton Réessayer ;

- mbIgnore : bouton Ignorer ;

- mbAll : bouton Tous.

Remarque : on peut utiliser trois constantes ordinales regroupant plusieurs constantes TMsgDlgBtn

- mbYesNoCancel : équivalent à [mbYes,mbNo,mbCancel] ;

- mbOkCancel : équivalent à [mbOk,mbCancel] ;

- mbAbortRetryIgnore : équivalent à [mbAbort,mbRetry,mbIgnore].

Le paramètre HelpCtx permet de sélectionner un écran d'aide qui sera exécuté si l'utilisateur valide le bouton d'Aide. Exemple :

MessageDlg('Bonjour',mtInformation,[mbOk],0);

La fonction MessageDlg retourne une valeur correspondant au bouton sélectionné. Pour analyser cette valeur, utilisez les constantes prédéfinies : mrNone, mrOk, mrCancel, mrAbort, mrRetry, mrIgnore, mrYes, mrNo, mrAbort, mrIgnore,mrAll.

Exemple :

if MessageDlg('Bonjour',mtInformation,[mbOk,mbCancel],0) = mrOk then

MessageDlgPos est une variante de MessageDlg qui permet de préciser la position de la boite de message. Les paramètres X et Y indiquent les coordonnées, en pixels du coin haut et gauche de la boite de dialogue.