Construction d'une application MDI

Dans cet exemple, nous allons suivre pas à pas la construction d'une application MDI. Notre application ne fera rien de particulier si ce n'est de gérer ses fenêtres enfants. Si vous suivez ce tutoriel pas à pas, vous devrez obtenir une application ressemblant à la capture d'écran ci-dessous :

Tout d'abord il faut créer une nouvelle application, nous reviendrons plus tard sur sa fiche principale Form1. Construisons en premier lieu le modèle de la fiche enfant (Form2).

Création de la fiche enfant (Form2) : sur le menu faire : « Fichier » puis « Nouveau » puis « Fiche », mettre sa propriété FormStyle à fsMDIChild.

Cette fiche ne doit pas être créée automatiquement au démarrage de l'application, nous devons donc la passer en fiche disponible : sur le menu faire « Projet » puis « Options… » puis sur la boîte de dialogue sélectionner l'onglet « Fiches » puis dans la liste de gauche (Fiches créées automatiquement) sélectionner Form2, appuyer sur le bouton « > », Form2 doit passer sur la liste de droite (Fiches disponibles). Si vous consultez le code source de project1.cpp vous remarquerez que cette ligne : Application->CreateForm(__classid(TForm2), &Form2); a disparu. Supprimer cette ligne manuellement donne donc le même résultat.

Pour agrémenter cette fiche, nous y placerons un TMemo avec sa propriété Align à alClient. Nous allons maintenant aborder le code de la fiche enfant

Unit2.h  : nous y déclarons une donnée membre static « Numero », elle existera donc en un seul exemplaire, quel que soit le nombre d'instances de la classe qui seront créées. Elle nous servira justement à compter ces instances pour leur donner un numéro que l'on affichera sur leur « Caption » :

#define Unit2H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
//---------------------------------------------------------------------------
class TForm2 : public TForm
{
__published:  // Composants gérés par l'EDI
        TMemo *Memo1;
        void __fastcall FormClose(TObject *Sender, TCloseAction &Action);
        void __fastcall FormCreate(TObject *Sender);
private:  // Déclarations de l'utilisateur
        static int Numero;
public:    // Déclarations de l'utilisateur
        __fastcall TForm2(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm2 *Form2;
//---------------------------------------------------------------------------
#endif

Unit2.cpp : dans le constructeur, on incrémente la donnée membre static « Numero » à chaque fois que l'on créera une nouvelle fiche enfant et on ajoutera ce numéro à son « Caption » sur l'événement OnCreate de la fiche. On pourrait aussi par exemple l'affecter à la propriété tag de la fiche pour avoir un numéro unique de chaque instance dans cette propriété. Dans l'événement OnClose de la fiche, on ajoutera Action = caFree; pour détruire la fiche. (Une fiche enfant MDI est minimisée par défaut sur l'événement OnClose.)

#include <vcl.h>
#pragma hdrstop

#include "Unit2.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm2 *Form2;
int TForm2::Numero = 0;
//---------------------------------------------------------------------------
__fastcall TForm2::TForm2(TComponent* Owner)
        : TForm(Owner)
{
        Numero++;
}
//---------------------------------------------------------------------------
void __fastcall TForm2::FormClose(TObject *Sender, TCloseAction &Action)
{
        Action = caFree;
}
//---------------------------------------------------------------------------
void __fastcall TForm2::FormCreate(TObject *Sender)
{
        Caption = "Fenêtre N° " + IntToStr(Numero);
}

Nous allons d'abord donner les propriétés suivantes à sa Form (Form1) :

FormStyle à fsMDIForm ;

Caption à Application MDI.

Puis poser sur la fiche un MainMenu (MainMenu1) avec un premier menu nommé « Fichier » ayant deux options de menu, « New » et « Quitter » puis un second menu nommé « Fenêtre » avec trois options « Cascade », « Horizontale » et « Verticale ».

Unit1.cpp : tout d'abord inclure Unit2.h pour avoir accès au model de la fiche enfant. Puis sur l'événement OnClick de l'option de menu « New », nous créons dynamiquement une fiche enfant (Form2). Sur l'événement OnClick de « Quitter », nous fermons l'application. Sur l'événement OnClick de « Cascade », nous mettons les fenêtres enfants en cascade avec la méthode Cascade. Sur les événements OnClick de « Horizontale » et « Verticale », nous mettons les fenêtres enfants en mosaïque horizontale ou verticale à l'aide de la méthode Tile en fonction de l'état de la propriété TileMode :

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
#include "Unit2.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::New1Click(TObject *Sender)
{
      Form2 = new TForm2(this);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Quitter1Click(TObject *Sender)
{
      Close();
} 
//---------------------------------------------------------------------------
void __fastcall TForm1::Cascade1Click(TObject *Sender)
{
      Cascade();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Horizontale1Click(TObject *Sender)
{
      TileMode = tbHorizontal;
      Tile();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Verticale1Click(TObject *Sender)
{
      TileMode = tbVertical;
      Tile();
}

Vous pouvez dès maintenant compiler l'application. Vous pouvez vous apercevoir qu'avec peu de code elle est déjà fonctionnelle.

Vous pouvez voir que les fiches enfants occupent toute la zone client de la fenêtre parent. On peut se réserver une partie de la fiche parent pour mettre par exemple des boutons comme sur la capture d'écran que vous avez pu voir au début de cet article. Pour cela nous poserons sur la fiche un TPanel avec les propriétés suivantes :

Align à Left

Caption à Vide

BevelOuter à bvNone

Sur ce panel vous pouvez poser ce dont vous avez besoin. Dans la capture d'écran en exemple j'avais posé deux SpeedButtons dont j'avais affecté les événements OnClick aux méthodes des menus New1Click et Quitter1Click.

IV-A. Les menus▲

IV-B. Accès à la fiche enfant active depuis la fiche principale▲

//...
void __fastcall TForm1::Fermer1Click(TObject *Sender)
{
     if(ActiveMDIChild)  ActiveMDIChild->Close();
}
//...

IV-C. Accès à un objet de la fiche enfant active depuis la fiche principale▲

//...
void __fastcall TForm1::Clear1Click(TObject *Sender)
{
     if(ActiveMDIChild)
          ((TForm2 *)ActiveMDIChild)->Memo1->Lines->Clear();
}
//...

IV-D. Accès à toutes les fiches enfants▲

//...
void __fastcall TForm1::Toutfermer1Click(TObject *Sender)
{
      for(int x = MDIChildCount-1; x>=0; x--)
                               MDIChildren[x]->Close();
}
//...

IV-E. Passer le focus à la fiche suivante ou précédente▲