1. Les fiches sont des objets de la classe TForm

Les fenêtres sont des objets de la classe TForm qui représente une fénêtre. En tant qu'objet, 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 succeptibles de ce produire.

1.1. Les propriétés d'une fiches

Nom Description
BorderIcons

spécifie les differentes icones apparaissant dans la barre de titre en valorisant cette propriété avec les valeurs suivantes :

  • biSystemMenu (menu systeme),
  • biMinimize (bouton réduction),
  • biMaximize (bouton agrandissement).
 
Sélectionnez
BorderIcons := [biSystemMenu, biMinimize, biMaximize];
	BorderIcons := []; (* pour supprimer tout les icones*)
								
BorderStyle

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

  • bsDialog : bordure simple, non redimensionnable
  • bsNone : aucune bordure donc aucune icone dans la barre de titre, impossible de déplacer le fenêtre.
  • bsSingle : bordure simple non redimensionnable
  • bsSizeable : bordure double, la fiche est redimentionnable
Caption

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

WindowState

définie 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éfinie l'image du curseur de la souris lorqu'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

determine 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é automatiquement
  • poDefaultPosOnly : taille de la conception avec position déterminé par Delphi
  • poDefaultSizeOnly : position de la conception avec taille déterminé par Delphi
  • poScreenCenter : la fenêtre est positionné 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é 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és 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é par ShowModal :

 
Sélectionnez
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.

1.2. 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 fenetre

 
Sélectionnez
SetBounds(aleft, atop, awidth, aheight)
							

Cette methode effectue les modification 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 modal. 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

1.3. Les événements d'une fiche

Une grande partie du code source d'une application est écrit 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'objet. Si le nom saisi ne correspond à aucune méthode existante, le gestionnaire d'événements 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 implementation 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'empeche 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'origine différente Il est donc possible de définir une méthode générique applicable à n'importe quelle composants. 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'évenement 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 :

 
Sélectionnez
Composant.UneMethode(Sender : TObject);
				

Lorsque l'on opère de cette façon, il devient nécessaire de pouvoir détermininer le composant exact qui a généré l'événement. C'est le paramètre Senderde la méthode événement qui permet cela puiqu'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 connaître le type et le nom de la classe du composant concerné par l'événement.

exemple :

 
Sélectionnez
var
	  f : TForm;
	  b : TButton ;
	begin
	  (* test 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;

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

1.3.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 seul fonction est d'indiquer à un composant qu'un événement s'est produit, comme 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 :
    • a 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 lorque le focus se trouve dans un bouton ou une case à cocher
    • l'appui sur la touche Entree 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 click
  • OnMouseDown est généré lors de l'appui sur un bouton de la souris
  • OnMouseUp est généré lors du relachement de ce bouton

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

 
Sélectionnez
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 :

 
Sélectionnez
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 controle (ALT, CTRL ou MAJ) était maintenue enfoncée lorque l'événement souris est survenu.

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

 
Sélectionnez
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 maintenue enfoncée
  • ssRight le bouton droit de la souris est maintenue enfoncée
  • ssMiddle le bouton gauche de la souris est maintenue enfoncée
  • 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 relaché le bouton de la souris. Les coordonnées sont exprimées en pixels

  • OnMouseMove est généré lorque le curseur de la souris est déplacé dans la partie visible d'un composant. Le type de cette propriété est TMouseMoveEvent
 
Sélectionnez
TMouseMoveEvent = procedure(Sender : TObject; TShift : TShiftState; X, Y : Integer) of objet;
						

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

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

1.3.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 :
 
Sélectionnez
TKeyEvent = procedure(Sender : TObject ; var key : Word ; Shift : TShiftState) of object;
						

Sender contient le composant associé à cette é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'éxécution d'un programme
  • VK_BACK retour arrière
  • VK_TAB tabulation
  • VK_RETURN entrée
  • VK_SHIFT touche de controle MAJ
  • VK_CONTROL touche de controle CTRL
  • VK_MENU touche de controle ALT
  • VK_PAUSE pause
  • VK_ESCAPE echappement
  • 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 vérouillage 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 relachée

exemple :

 
Sélectionnez
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 relachement des touches ne sont pas distingués. Le type de OnKeyPress est TKeyPressEvent :

 
Sélectionnez
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 controle 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 reserve que les propriétés OnKeyPress, OnKeyDown ou OnKeyUp ne soient pas toutes vides. Lorsque KeyPreview est à True, les méthodes associés 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és 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 ou le parametre 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énement 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 controle :

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

1.4. 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é à la génération d'un événement OnClose, de type TCloseEvent. Ce type est défini de la façon suivante :

 
Sélectionnez
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 pa 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

 
Sélectionnez
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éroulenement 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. A nouveau le procesus peut être interrompu ou détourné par l'indication d'une valeur à l'argument Action

1.5. 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.

1.5.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 suceptibles 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

1.5.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 boîte 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.

1.5.3. Les propriétés associées au focus

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

Pour agir sur la possibilité qu'à 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 controle reste activable, à l'aide de la souris par exemple.

1.5.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 :

 
Sélectionnez
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'occurence d'un événement OnEnter, du type procédural TNotifyEvent. Le départ du focus génère un événement OnExit.

2. 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.

2.1. Le style d'une fenêtre MDI

Du point de vue de la comception, les deux types de fiche (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 quatres 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éer 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'éxé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 demarche 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.

2.2. 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 :

 
Sélectionnez
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ément du tableau MDIChildren qui contient les références de toutes les fenêtres enfants de l'application.

 
Sélectionnez
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

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

2.3. 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 quant il n'existe qu'un seul modèle de fiche fille. Par exemple, pour ne faire apparaître l'option edition 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 :

 
Sélectionnez
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ères et fille 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és à 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 :

 
Sélectionnez
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éclarer l'une des options de menu de la barre principale des menus dans la propriété WindowMenu. A 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 inclures des options de menu contenant les commandes Mosaique, Cascade et Reorganiser les icones afin que les utilisateurs puissent modifier la disposition de leurs documents ouverts dans la zone client de la fenêtre cadre.

2.4. 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 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 l'on souhaite modifier le comportement par défaut de Tile, inserer une instruction modifiant la valeur de TileMode

 
Sélectionnez
TileMode:=tbVertical;
Tile;
				

2.5. 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.

2.6. La réorganisation des icones

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

 
Sélectionnez
ArrangeIcons;
				

2.7. 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.

3. L'affichage d'une boîte 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 boîte de message centrée sur l'écran et contenant un libellé adressé à l'utilisateur :

 
Sélectionnez
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 boîte de dialogue. Il existe cinq valeur :

  • 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 boîte 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 : Equivalent à [mbYes,mbNo,mbCancel]
  • mbOkCancel : Equivalent à [mbOk,mbCancel]
  • mbAbortRetryIgnore : Equivalent à [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 :

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

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

Exemple :

 
Sélectionnez
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 heut et gauche de la boîte de dialogue.