La programmation Win32 en Virtual Pascal avec OWL

VII-B-1-a. Création d'un crayon▲

Function CreatePen (Style, Width : Integer; Color : tColorRef) : hPen;

VII-B-1-b. Création d'un pinceau▲

Function CreateSolidBrush (Color : tColorRef) : hBrush;
Function CreateHatchBrush (Style : LongInt; Color : tColorRef) : hBrush;

VII-B-1-c. Sélection des outils de dessin dans le DC▲

Function SelectObject (DC : hDC; GDIObj : hGDIObj) : hGDIObj;

VII-B-1-d. Destruction des outils de dessin▲

Function DeleteObject (GDIObject : tHandle) : Bool;

VII-B-1-e. Illustration : amélioration de la méthode PAINT▲

Procedure tFenetrePrincipale.PAINT (PaintDC : hDC; var PaintInfo : tPaintStruct);
(* Dessin d'un cercle et bip sonore *)
Var AncienCrayon, Crayon : hPen;
    AncienPinceau, Pinceau : hBrush;
Begin
  (* Création des outils de dessin *)
  Crayon := CreatePen(ps_Solid,3,RGB(255,0,0));
  AncienCrayon := SelectObject(PaintDC,Crayon);
  Pinceau := CreateSolidBrush(RGB(128,128,128));
  AncienPinceau := SelectObject(PaintDC,Pinceau);
  (* Dessin *)
  Ellipse(PaintDC,10,10,100,100);
  (* Destruction des outils de dessin *)
  SelectObject(PaintDC,AncienPinceau);
  DeleteObject(Pinceau);
  SelectObject(PaintDC,AncienCrayon);
  DeleteObject(Crayon);
  (* Bip sonore *)
  MessageBeep(mb_IconExclamation);
End;

La seule ressource utilisée par le programme est une image bitmap monochrome de 64 X 64 pixels, entièrement noire. Elle servira à peindre le fond de la fenêtre, comme nous l'avons déjà vu dans le programme FONDEMAR.PAS.
L'identificateur de la bitmap, id_FondNoir, se trouve dans le fichier include ONDOYANT.INC, lié au source par la directive

{$I ONDOYANT.INC}

La ressource compilée sous forme binaire se trouve, elle, dans le fichier ONDOYANT.RES, lié à notre programme par la directive

{$R ONDOYANT.RES}

Tout ceci n'est qu'un rappel de ce qui a déjà été vu au Chapitre VI.
C'est ainsi que :

• Le pinceau noir pour le fond est créé dans la méthode Init
• Ce pinceau est affecté à la classe de fenêtre dans la méthode GetWindowClass
• Le pinceau est détruit dans le destructeur Done

Pour ses graphismes animés, notre programme utilise une horloge, un timer. Windows peut mettre à la disposition des applications un nombre restreint d'horloges réglables en millisecondes. Toutefois, la précision de ces horloges est relativement faible; c'est dû à la manière dont le système gère le multitâche. Mais pour notre programme, il n'y a pas besoin d'une grande précision.

Nous allons donc créer un timer et lui demander d'envoyer un message wm_Timer à la fenêtre principale du programme à chaque tic d'horloge. C'est dans une méthode virtuelle indexée WMTIMER que nous allons dessiner les lignes ondoyantes.

La création du timer s'effectue dans la méthode SetupWindow :

Procedure tFenetrePrincipale.SETUPWINDOW;
(* Mise en route du timer *)
Begin
  tWindow.SETUPWINDOW;
  SetTimer(hWindow,IdTimer,VitesseTimer,Nil);
End;

Pourquoi dans cette méthode ? Parce que la fonction SetTimer a besoin du handle de la fenêtre à laquelle les messages wm_Timer sont destinés. Le champ hWindow d'un objet tWindow contient son handle.

La méthode SetupWindow est le premier endroit où le champ hWindow d'une fenêtre est défini

C'est le rôle premier de SetupWindow : permettre de configurer une fenêtre avant qu'elle soit affichée, en ayant déjà son handle à disposition.

Détaillons à présent la fonction SetTimer :

Function SetTimer (Wnd : hWnd; IdEvent, Elapse : UInt; TimerFunc : tFNTimerProc) : UInt;

• Wnd est le handle de la fenêtre à laquelle les messages wm_Timer sont destinés
• IdEvent est l'identificateur du timer
• Elapse est la fréquence des tics d'horloge, en millisecondes
• TimerFunc est l'adresse d'une fonction de rappel (technique que nous n'utilisons pas ici, donc Nil)

Dans la déclaration des constantes de notre programme, nous avons défini IdTimer comme identificateur pour le timer. Le rôle de l'identificateur du timer est de permettre, éventuellement, de différencier les messages wm_Timer envoyés par plusieurs timers créés simultanément.

Il ne faut surtout pas oublier de détruire le timer avant la fin du programme !

Un bon endroit pour détruire le timer est une méthode WMDESTROY :

Alors que la méthode SetupWindow est le premier endroit où le handle hWindow est défini, WMDESTROY est le dernier endroit où celui-ci est valide, dans le processus de destruction de la fenêtre

La fonction utilisée pour détruire un timer est KillTimer. Il faut bien sûr l'appeler avant d'appeler la méthode WMDESTROY de l'objet ancêtre tWindow :

Procedure tFenetrePrincipale.WMDESTROY (var Msg : tMessage);
(* Destruction du timer *)
Begin
  KillTimer(hWindow,IdTimer);
  tWindow.WMDESTROY(Msg);
End;

Comme nous l'avons déjà dit, c'est dans la méthode WMTIMER que les lignes sont dessinées. Nous les dessinons par lots de 10 de couleur identique; vous pouvez bien sûr changer ce nombre.

Voici la méthode WMTIMER :

Procedure tFenetrePrincipale.WMTIMER (var Msg : tMessage);
(* Dessin de 10 lignes *)
Var DC : hDC;                 (* Contexte d'affichage *)
    ClientRect : tRect;       (* Taille de la zone client *)
    i : LongInt;              (* Indice dans le tableau *)
    AncienIndice : LongInt;   (* Sauvegarde de l'indice général *)
Begin
  DC := GetDC(hWindow);
  GetClientRect(hWindow,ClientRect);
  for i := 1 to 10 do
    begin
      AncienIndice := IndiceGeneral;
      if IndiceGeneral = IndiceMax - 1
         then
           begin   (* Le tour du tableau est fait *)
             IndiceGeneral := 0;
             Effacer := True;
           end
         else
           Inc(IndiceGeneral);
      if Effacer
         then   (* Effacement par dessin avec opération XOR *)
           DESSINLIGNE(DC,IndiceGeneral);
      TabLignes[IndiceGeneral] := TabLignes[AncienIndice];
      (* Création d'une nouvelle ligne *)
      with TabLignes[IndiceGeneral] do
        begin
          NOUVELLELIGNE(DC,x1,dx1,ClientRect.Right,Couleur);
          NOUVELLELIGNE(DC,y1,dy1,ClientRect.Bottom,Couleur);
          NOUVELLELIGNE(DC,x2,dx2,ClientRect.Right,Couleur);
          NOUVELLELIGNE(DC,y2,dy2,ClientRect.Bottom,Couleur);
        end;
      (* Dessin de la nouvelle ligne *)
      DESSINLIGNE(DC,IndiceGeneral);
    end;
  ReleaseDC(hWindow,DC);
End;

Vous voyez tout d'abord qu'un handle de contexte de périphérique est demandé à Windows. En effet, alors que la méthode Paint que nous avons vue fournit elle-même un handle de DC (PaintDC), ici nous devons le demander au système pour pouvoir dessiner à l'écran. La fonction GetDC ne nécessite que le handle de la fenêtre comme paramètre et retourne le handle du contexte de périphérique :

Function GetDC (Wnd : hWnd) : hDC;

Dans un souci de pureté, il conviendrait à ce niveau de tester la valeur de retour de GetDC et de mettre fin à l'application si elle est nulle :

  DC := GetDC(hWindow);
  if DC <> 0
     then
       begin
         ...
       end
     else
       begin
         MessageBox(hWindow,'Plus de ressources syst'#232'me','Erreur',mb_IconHand or mb_Ok);
         CloseWindow;
       end;

Cela signifierait que Windows n'a plus de contexte de périphérique disponible, ce qui est rare mais pas impossible. D'ailleurs, l'effondrement total du système serait proche...

La méthode CloseWindow, héritée de l'objet ancêtre tWindowsObject, détruit la fenêtre principale et met fin à l'application.

Il ne faut pas confondre la méthode CloseWindow avec la fonction de l'API du même nom qui, elle, sert à minimiser une fenêtre

Nous avons déjà insisté sur la nécessité de libérer un contexte de périphérique dès que possible, vu que Windows en dispose en nombre limité. Donc, à la fin de la méthode WMTIMER, nous restituons le DC à l'aide de la fonction ReleaseDC :

Function ReleaseDC (Wnd : hWnd; DC : hDC) : Integer;

• Wnd est le handle de la fenêtre
• DC est le handle du contexte de périphérique obtenu par GetDC

Rappelons encore une fois qu'avant d'être libéré, le DC soit être restauré dans son état initial. C'est bien ce que nous nous sommes attachés à faire dans notre méthode DESSINLIGNE.


Mais revenons à la manière dont fonctionne notre programme. Dans la boucle qui effectue les 10 itérations, vous pouvez voir que le champ Effacer, déclaré dans l'objet tFenetrePrincipale et initialisé à False dans le constructeur de la fenêtre, devient définitivement True dès que le tour des 100 éléments du tableau des lignes a été effectué au moins une fois. Cela entraîne que, à partir du moment où 100 lignes se trouvent à l'écran, il faudra en effacer une pour en dessiner une autre, de manière à ne jamais dépasser les 100 lignes simultanément affichées.

Or, justement, pour effacer une ligne vous voyez que l'on appelle la méthode DESSINLIGNE ?!?
Eh bien oui, cette méthode permet d'effacer une ligne en la redessinant. Regardons-la de plus près :

Procedure tFenetrePrincipale.DESSINLIGNE (DC : hDC; i : Integer);
(* Dessine ou efface la ligne d'indice i *)
Var AncienCrayon, Crayon : hPen;
    AncienneROP : LongInt;
Begin
  with TabLignes[i] do
    begin
      Crayon := CreatePen(ps_Solid,1,Couleur);
      AncienCrayon := SelectObject(DC,Crayon);
      AncienneROP := SetROP2(DC,r2_XORPen);
      MoveTo(DC,x1,y1);
      LineTo(DC,x2,y2);
      SelectObject(DC,AncienCrayon);
      DeleteObject(Crayon);
      SetROP2(DC,AncienneROP);
    end;
End;

C'est la fonction GDI SetROP2 qui permet indifféremment de dessiner ou effacer une ligne. ROP est l'abréviation de Raster OPeration. Raster, qui signifie trame, fait référence à la trame de pixels de l'écran.
SetROP2 permet d'appliquer une opération logique entre la couleur à appliquer à un pixel et la couleur actuelle de ce pixel à l'écran. En utilisant l'opération r2_XORPen, si les pixels de l'écran sont de la couleur du fond alors les pixels de la ligne prendront la couleur désirée et, inversément, si les pixels ont déjà la couleur de la ligne, ils reprendront la couleur du fond.

L'opération r2_XORPen est une manière très intéressante d'effacer un élément dessiné à l'écran

Voici un tableau de toutes les opérations logiques applicables par SetROP2 :

Un seul conseil : expérimentez ces différentes opérations !

Important : dans le but de restaurer le contexte de périphérique dans son état initial avant de le libérer, il faut absolument sauvegarder l'opération logique initiale au moment de l'appel de SetROP2. C'est le but de la variable locale AncienneROP.


Il nous reste encore à parler de la manière dont le programme détermine la taille de la fenêtre, afin de pouvoir donner l'impression que les lignes rebondissent sur ses bordures :

Procedure tFenetrePrincipale.WMTIMER (var Msg : tMessage);
(* Dessin de 10 lignes *)
Var DC : hDC;                 (* Contexte d'affichage *)
    ClientRect : tRect;       (* Taille de la zone client *)
    ...
Begin
  DC := GetDC(hWindow);
  GetClientRect(hWindow,ClientRect);
  ...

La fonction GetClientRect permet de connaître la taille de la zone client de la fenêtre, c'est-à-dire la zone intérieure comprise entre la barre de titre (s'il n'y a pas de menu) ou le menu et les bordures de la fenêtre. Le résultat de GetClientRect est retourné sous la forme d'une structure de type tRect :

Type tPoint = Record
                X : Long;
                Y : Long;
              end;
     tRect = Record
               case Integer of
                 0 : (Left, Top, Right, Bottom : Integer);
                 1 : (TopLeft, BottomRight : tPoint);
             end;

• Left est l'abscisse du point extrême haut-gauche du rectangle
• Top est son ordonnée
• Right est l'abscisse du point extrême bas-droite du rectangle
• Bottom est son ordonnée

Les champs Right et Bottom de la variable locale ClientRect sont passés comme paramètres à la méthode NOUVELLELIGNE, qui est chargée de créer les coordonnées et la couleur d'une nouvelle ligne.

Mine de rien, il ne faudrait pas grand chose pour que notre programme ressemble à un screen-saver ! Alors, nous allons lui ajouter quelques fonctionnalités :

• Lui faire remplir tout l'écran
• Arrêter son exécution dès qu'on touche au clavier ou à la souris

Bien qu'il s'agisse d'un programme Windows conventionnel, la structure d'un vrai screen-saver doit répondre à plusieurs spécifications bien précises qui sortent du cadre de ce tutoriel : sa vitesse et sa résolution doivent être paramétrables, il doit pouvoir être visible dans une petite fenêtre d'aperçu, etc.

Quoi qu'il en soit, après avoir modifié le programme ONDOYANT, nous pourrons le renommer en .SCR et l'utiliser comme screen-saver.

Tout d'abord, pour lui faire prendre tout l'écran, sans que soient visibles la barre de titre ni la moindre bordure, nous allons fixer nous-même la taille et la position de la fenêtre principale. Car, jusqu'à présent, nous avons laissé au système le soin de positionner et dimensionner toutes nos fenêtres.

Dans le constructeur Init de la fenêtre principale, nous allons donner des valeurs aux champs X, Y, W et H du champ Attr de l'objet descendant de tWindow. Rappelez-vous, nous avons déjà abordé le champ Attr dans le chapitre sur les ressources.
X et Y étant les coordonnées du point haut-gauche de la fenêtre, il est logique de leur donner une valeur nulle - puisque le 1er pixel tout en haut de l'écran a les coordonnées (0,0). Pour donner à la fenêtre la largeur (W) et la hauteur (H) de l'écran, il nous faut déterminer ces valeurs au moyen de la fonction GetSystemMetrics :

Function GetSystemMetrics (Index : Integer) : Integer;

Comme son nom l'indique, cette fonction retourne des mesures d'éléments du système. Elle attend un index et retourne la mesure qui correspond à cet index. Pour connaître la largeur et la hauteur de l'écran, il faut utiliser respectivement comme index sm_CXScreen et sm_CYScreen. Vous pouvez consulter le SDK pour voir tous les index possibles; il y en a plusieurs dizaines et vous constaterez que GetSystemMetrics permet d'obtenir des renseignements aussi divers que le type de boot ou le nombre de boutons de la souris.

Modifions le constructeur de la fenêtre principale :

Constructor tFenetrePrincipale.INIT (aParent : pWindowsObject; aTitle : pChar);
(* Style & taille - Pinceau pour le fond - Initialisation des champs *)
Var h : hBitmap;
    i : LongInt;
Begin
  tWindow.INIT(aParent,aTitle);
  (* Taille de la fenêtre *)
  Attr.X := 0;
  Attr.Y := 0;
  Attr.W := GetSystemMetrics(sm_CXScreen);
  Attr.H := GetSystemMetrics(sm_CYScreen);
  (* Création du pinceau pour le fond *)
  ...
End;

Recompilez le source ainsi modifié et exécutez-le : la fenêtre prend bien toute la largeur et toute la hauteur de l'écran mais la barre de titre et les bordures sont encore visibles. Donc, ce n'est pas encore terminé : la dernière modification à apporter à la fenêtre est de lui choisir un style particulier.

Si vous êtes un utilisateur habituel de Windows, vous n'avez certainement pas manqué de remarquer que toutes les fenêtres de tous les programmes ne sont pas absolument identiques : certaines ont une barre de titre et d'autres pas, certaines ont une bordure épaisse et d'autres une bordure fine ou même pas de bordure du tout, certaines peuvent être déplacées et dimensionnées par l'utilisateur alors que d'autres pas, etc, etc. Toutes ces différences sont dues à l'utilisation d'attributs de style différents.

Mis à part certains attributs s'excluant mutuellement, les attributs de style peuvent être combinés au moyen d'une opération logique or.

Dans le cas qui nous occupe, la combinaison des attributs de style ws_Popup (pour une fenêtre simple sans barre de titre ni bordure) et ws_Visible (pour une fenêtre visible, vous aviez deviné) correspond exactement à notre attente.
Modifions donc une dernière fois le constructeur de la fenêtre principale :

Constructor tFenetrePrincipale.INIT (aParent : pWindowsObject; aTitle : pChar);
(* Style & taille - Pinceau pour le fond - Initialisation des champs *)
Var h : hBitmap;
    i : LongInt;
Begin
  tWindow.INIT(aParent,aTitle);
  (* Style et taille de la fenêtre *)
  Attr.Style := ws_Popup or ws_Visible;
  Attr.X := 0;
  Attr.Y := 0;
  Attr.W := GetSystemMetrics(sm_CXScreen);
  Attr.H := GetSystemMetrics(sm_CYScreen);
  (* Création du pinceau pour le fond *)
  ...
End;

Si vous compilez et exécutez le programme, vous voyez que c'est gagné : il prend l'entièreté de l'écran !

La dernière étape à effectuer est de faire en sorte que le programme s'arrête dès qu'une touche est pressée ou dès que l'on touche à la souris, comme un vrai screen-saver. Avec ce que nous avons déjà vu, vous devriez déjà être capable de deviner comment réaliser cela : tout simplement en créant des méthodes virtuelles indexées qui vont réagir aux messages du clavier et de la souris. Pour fermer le programme, nous appellerons la méthode CloseWindow :

Procedure tFenetrePrincipale.WMKEYDOWN (var Msg : tMessage);
(* Fermeture de la fenêtre quand touche pressée *)
Begin
  CloseWindow;
End;

Procedure tFenetrePrincipale.WMMOUSEMOVE (var Msg : tMessage);
(* Fermeture de la fenêtre quand mouvement de souris *)
Begin
  CloseWindow;
End;

Procedure tFenetrePrincipale.WMLBUTTONDOWN (var Msg : tMessage);
(* Fermeture de la fenêtre quand clic de souris *)
Begin
  CloseWindow;
End;

VII-C-4-a. Attributs de style de fenêtre▲

Comme vous le voyez sur le screenshot ci-dessus, notre programme contient un menu et une table d'accélérateurs (dont les combinaisons de touches apparaissent dans le menu). Il n'y a aucune difficulté particulière dans la création de ces deux ressources - ne vous préoccupez pas pour l'instant de la marque de cochage de la commande Rectangle. Vous pouvez bien sûr toujours vous référer au chapitre consacré à la création de ressources.

Voici le source du fichier FORMES.RC :

#include "formes.inc"

id_MenuPrincipal MENU 
{
 POPUP "&Commandes"
 {
  MENUITEM "&Rectangle\tAlt-R", cm_Rectangle
  MENUITEM "&Ellipse\tAlt-E", cm_Ellipse
  MENUITEM "&Ligne\tAlt-L", cm_Ligne
  MENUITEM SEPARATOR
  MENUITEM "&Supprimer tout\tSuppr", cm_Supprimer
  MENUITEM SEPARATOR
  MENUITEM "&Quitter", cm_Exit
 }
}
id_Accel ACCELERATORS 
{
 "r", cm_Rectangle, ASCII, ALT
 "e", cm_Ellipse, ASCII, ALT
 "l", cm_Ligne, ASCII, ALT
 VK_DELETE, cm_Supprimer, VIRTKEY
}

Contenu du fichier FORMES.INC :

const
        cm_Rectangle     = 101;
        cm_Ellipse       = 102;
        cm_Ligne         = 103;
        cm_Supprimer     = 104;
        cm_Exit          = 24340;
        id_MenuPrincipal = 1;
        id_Accel         = 2;

Afin d'indiquer à l'utilisateur que le programme attend un clic de souris pour dessiner, nous allons remplacer le curseur par défaut (la bonne vieille flèche) par un curseur plus adapté, une croix (+). En plus, il sera plus facile avec ce curseur de positionner la souris avec précision à l'écran.

Dans le chapitre consacré aux ressources, nous avons vu comment créer un curseur personnalisé. Mais ici nous n'en avons pas besoin car Windows possède déjà en stock le curseur qu'il nous faut !

Function tFenetrePrincipale.GETCLASSNAME : pChar;
(* Retourne le nom de classe de la fenêtre *)
Begin
  GETCLASSNAME := 'Formes';
End;

Procedure tFenetrePrincipale.GETWINDOWCLASS (var aWndClass : tWndClass);
(* Définition du curseur de classe de la fenêtre *)
Begin
  tWindow.GETWINDOWCLASS(aWndClass);
  aWndClass.hCursor := LoadCursor(0,idc_Cross);
End;

Dans une fonction de chargement de ressource (LoadIcon, LoadCursor...), l'utilisation de 0 comme handle d'instance donne accès aux objets du stock de Windows

En utilisant 0 comme handle d'instance (au lieu de la variable hInstance, que nous avons utilisée jusqu'à présent), nous pouvons donc charger un curseur du stock de Windows. L'identificateur de la croix que nous allons utiliser est idc_Cross.

Voici les curseurs disponibles dans le stock de Windows :

Identificateur	Curseur
idc_Arrow
idc_Wait
idc_AppStarting
idc_Cross
idc_IBeam
idc_No
idc_UpArrow
idc_SizeWE
idc_SizeNS
idc_SizeNWSE
idc_SizeNESW
idc_Size / idc_SizeAll

Notre programme permettra à l'utilisateur de choisir trois types de formes géométriques : rectangle, ellipse ou ligne droite. Au démarrage du programme, la forme sélectionnée sera le rectangle et donc la commande de menu correspondante sera cochée. Le type de forme en cours sera stocké dans un champ de la fenêtre principale, FormeCourante. Et quoi de plus simple que d'utiliser directement l'identificateur de commande ? Dans le constructeur de la fenêtre, le champ FormeCourante recevra donc la commande cm_Rectangle.

Le cochage d'une commande de menu se fait à l'aide de la fonction CheckMenuItem :

Function CheckMenuItem (Menu : hMenu; IDCheckItem, Check : UInt) : DWord;

• Menu est le handle du menu
• IdCheckItem permet d'identifier la commande à cocher
• Check est l'option de cochage à appliquer

Lorsque nous chargeons une ressource de type menu, dans le constructeur de notre fenêtre principale, nous avons vu que le handle retourné par la fonction LoadMenu est stocké dans le champ Attr.Menu de l'objet descendant de tWindow. C'est donc ce handle qui sera passé comme paramètre Menu de la fonction CheckMenuItem.

Les deux autres paramètres sont en quelque sorte liés : la valeur de IdCheckItem dépendra de celle de Check. Je m'explique : Check est une combinaison logique (or) entre l'option de cochage à appliquer (mf_Checked pour cocher la commande ou mf_Unchecked pour la décocher) et un paramètre permettant de déterminer si IdCheckItem identifie la commande du menu à (dé)cocher ou bien représente la position de cette commande dans le menu. Ainsi, si Check est une combinaison or de mf_Checked et mf_ByCommand, cela signifie que le paramètre IdCheckItem contient l'identificateur de la commande qu'il faut cocher tandis que, si Check est la combinaison de mf_Checked et mf_ByPosition, cela signifie que IdCheckItem contient le n° d'ordre de la commande à cocher dans le menu.

Dans le présent programme, nous utilisons mf_ByCommand :

CheckMenuItem(Attr.Menu,cm_Rectangle,mf_ByCommand or mf_Checked);

Dans le corps du programme, chaque fois que l'utilisateur changera de type de forme géométrique à dessiner, nous devrons décocher la commande courante et cocher la nouvelle commande. Cette action aura lieu en réponse à une des commandes de choix de figure.

Nous utiliserons une méthode WMCOMMAND pour répondre aux commandes, comme dans le programme CHGFOND créé dans le chapitre précédent :

Procedure tFenetrePrincipale.WMCOMMAND (var Msg : tMessage);
(* Réponse aux messages de commandes *)
Begin
  case LoWord(Msg.wParam) of
    cm_Rectangle..cm_Ligne : if not BoutonEnfonce
                                then   (* Changement de forme *)
                                  begin
                                    CheckMenuItem(Attr.Menu,FormeCourante,mf_ByCommand or mf_Unchecked);
                                    FormeCourante := LoWord(Msg.wParam);
                                    CheckMenuItem(Attr.Menu,FormeCourante,mf_ByCommand or mf_Checked);
                                  end;
  else
    tWindow.WMCOMMAND(Msg);
  end;
End;

Rappelons que nous avons décidé de stocker la forme courante dans le champ FormeCourante de la fenêtre principale. Nous décochons donc d'abord la commande en passant ce champ comme paramètre IdCheckItem de la fonction CheckMenuItem, avec comme paramètre Check la combinaison mf_ByCommand or mf_Unchecked; ensuite, la nouvelle commande, qui se trouve dans le mot de poids faible du champ wParam du message de commande, est copiée dans le champ FormeCourante; enfin, nous cochons la nouvelle commande.

Penchons-nous tout d'abord sur la méthode qui sera chargée de dessiner une forme :

Procedure tFenetrePrincipale.DESSIN_FORME (DC : hDC);
(* Dessin d'une forme aux coordonnées courantes *)
Begin
  case FormeCourante of
    cm_Rectangle : Rectangle(DC,x1,y1,x2,y2);
    cm_Ellipse : Ellipse(DC,x1,y1,x2,y2);
    cm_Ligne : begin
                 MoveToEx(DC,x1,y1,Nil);
                 LineTo(DC,x2,y2);
               end;
  end;
End;

Très simple, cette procédure aura besoin des éléments suivants :

• Un contexte de périphérique
• Le type de forme à dessiner
• Les coordonnées de la forme

Le contexte de périphérique, DC, sera fourni par la procédure appelante. Le type de forme à dessiner est déjà stocké dans le champ FormeCourante de la fenêtre principale. Par contre, les coordonnées de début (x1,y1) et de fin (x2,y2), nous n'en avons pas encore parlé : la manière la plus simple sera de les déclarer eux aussi comme champs de l'objet fenêtre principale.

Parmi les fonctions GDI de dessin utilisées, nous avons déjà abordé Ellipse plus haut dans ce chapitre. La fonction Rectangle, dont je ne vous fais pas l'affront de vous expliquer à quoi elle sert, est calquée sur Ellipse : ses paramètres sont rigoureusement identiques.

Pour dessiner une ligne, nous utilisons le couple de fonctions MoveToEx et LineTo :

Function MoveToEx (DC : hDC; X, Y : Integer; OldPos : pPoint) : Bool;
Function LineTo (DC : HDC; X, Y : Integer) : Bool;

Pour ceux qui ont travaillé avec l'unité Graph de Turbo Pascal, l'analogie est évidente avec les procédures MoveTo et LineTo.

MoveToEx fixe les coordonnées du point d'origine de la forme. LineTo dessine tout simplement une ligne à partir de ce point d'origine jusqu'aux coordonnées qui lui sont passées comme paramètres. Comme toutes les fonctions de dessin GDI, ces deux fonctions nécessitent comme paramètre un handle de contexte de périphérique (DC).

MoveToEx peut retourner les coordonnées de l'ancien point d'origine dans une structure de type tPoint; comme nous n'en avons pas besoin dans notre programme, nous transmettons Nil comme adresse.
Le type tPoint contient tout simplement un couple abscisse/ordonnée :

Type pPoint = ^tPoint;
     tPoint = Record
                X : Long;
                Y : Long;
              end;

Les fonctions GDI qui dessinent une forme incluent le point d'origine du dessin mais excluent le point de destination

Cette remarque n'est pas sans importance. Par exemple, si l'on utilise la fonction Rectangle :

Rectangle(DC,10,10,100,100);

Le rectangle dessiné à l'écran aura comme point d'origine (10,10) mais aura en réalité comme point de destination (99,99) !
Il y a une raison assez logique à cela : si l'on doit dessiner une série de formes successives, le point de destination d'une forme devient automatiquement le point d'origine de la forme suivante. Les formes ne se chevauchent donc pas.

Dans le cas de la fonction LineTo, le point de destination devient automatiquement le nouveau point d'origine pour le dessin suivant. Par exemple :

MoveToEx(DC,10,10);
LineTo(DC,100,100);
LineTo(DC,200,50);

Avant le premier LineTo, le point d'origine est fixé à (10,10) par la fonction MoveToEx. Le LineTo dessine une ligne de (10,10) à (99,99) et le point d'origine devient automatiquement (100,100) sans qu'il y ait besoin de réexécuter un MoveToEx. Le second LineTo, lui, dessine une ligne de (100,100) à (199,51) et le point d'origine devient (200,50)... et ainsi de suite.

Le dessin d'une forme débutera lorsque l'utilisateur aura cliqué avec le bouton gauche de la souris dans la zone client de la fenêtre. Cet événement sera géré dans une méthode virtuelle indexée WMLBUTTONDOWN :

Procedure tFenetrePrincipale.WMLBUTTONDOWN (var Msg : tMessage);
(* Clic gauche : début du dessin *)
Begin
  x1 := LoWord(Msg.lParam);
  y1 := HiWord(Msg.lParam);
  x2 := x1;
  y2 := y1;
  (* Capture de la souris jusqu'à la fin du dessin *)
  SetCapture(hWindow);
  (* Indicateur de bouton de souris enfoncé *)
  BoutonEnfonce := True;
End;

Que fait cette méthode ? Tout d'abord, elle stocke les coordonnées du début de la forme dans les champs x1 et y1 de l'objet fenêtre principale. Comme la forme a une taille nulle pour l'instant, les champs x2 et y2 seront identiques à x1 et y1.

Ensuite, elle capture la souris.

Capturer la souris entraîne que tous les messages de la souris arrivent à la fenêtre qui l'a capturée, même si la souris a quitté sa zone client

Pourquoi faire cela ? Tout simplement parce que si, une fois que le dessin d'une forme a commencé, la souris quitte la zone client de la fenêtre, nous ne saurons pas si le bouton gauche a été relâché. En nous assurant que tous les messages de la souris nous parviendront, nous sommes certains de pouvoir détecter quand le bouton gauche est relâché et donc quand le dessin de la forme en cours est terminé.

Le fait de capturer la souris entraîne que celle-ci est inutilisable en dehors de la fenêtre de notre application. Nous n'allons donc pas la capturer en permanence mais plutôt limiter sa capture à la durée du dessin d'une forme :

• Capture de la souris au début du dessin (clic gauche de la souris)
• Fin de la capture à la fin du dessin (quand le bouton est relâché)

Les deux fonctions qui permettent de capturer et libérer la souris sont très simples :

Function SetCapture (Wnd : hWnd) : hWnd;
Function ReleaseCapture : Bool;

SetCapture ne nécessite comme paramètre que le handle de la fenêtre capturante, qui recevra donc tous les messages de la souris. ReleaseCapture, qui libère la souris, n'a besoin d'aucun paramètre.

Pour en finir avec le début du dessin d'une forme, nous devons parler d'un dernier champ : BoutonEnfonce. Lorsque la souris se trouve dans la zone client de la fenêtre de notre programme, celle-ci reçoit des messages wm_MouseMove chaque fois que la souris est déplacée. Or, une fois que le dessin a débuté, quand le bouton gauche de la souris a été enfoncé, à chaque mouvement de la souris la forme est redessinée, et cela jusqu'à ce que le bouton gauche soit relâché.
Mais que se passe-t-il si la souris se déplace dans la zone client de la fenêtre sans qu'un dessin soit en cours ? Eh bien, si nous ne testons pas que le bouton gauche est enfoncé, nous risquons de dessiner des formes quand il ne le faut pas. Le champ BoutonEnfonce, de type booléen, est donc mis à True au début du dessin et à False lorsque le dessin est terminé.

Une fois que le dessin a débuté, l'utilisateur n'aura qu'à déplacer la souris pour modifier la taille et la forme de la figure géométrique. Il faut qu'il voie la figure changer à l'écran : notre programme va donc la redessiner en permanence jusqu'à ce que l'utilisateur la fixe une fois pour toutes en relâchant le bouton de la souris.

Tous les dessins intermédiaires se feront dans une méthode WMMOUSEMOVE, en réponse à chaque message de mouvement de la souris wm_MouseMove :

Procedure tFenetrePrincipale.WMMOUSEMOVE (var Msg : tMessage);
(* Mouvement de souris : dessin intermédiaire *)
Var DC : hDC;
    AncienPinceau : hBrush;
    AncienneROP : LongInt;
Begin
  if BoutonEnfonce
     then
       begin
         (* Obtention du DC, sélection pinceau invisible, choix ROP *)
         DC := GetDC(hWindow);
         AncienPinceau := SelectObject(DC,GetStockObject(Hollow_Brush));
         AncienneROP := SetROP2(DC,r2_Not);
         (* Effacement de la forme actuelle *)
         DESSIN_FORME(DC);
         (* Nouveau dessin *)
         x2 := LoWord(Msg.lParam);
         y2 := HiWord(Msg.lParam);
         DESSIN_FORME(DC);
         (* Libération du DC *)
         SetROP2(DC,AncienneROP);
         SelectObject(DC,AncienPinceau);
         ReleaseDC(hWindow,DC);
       end;
End;

VII-D-6-a. Pinceau invisible - Objets du stock de Windows▲

Function GetStockObject (Index : Integer) : hGDIObj;

VII-D-6-b. Coordonnées de la souris▲

VII-D-6-c. Effacement et dessin▲

La forme en cours est définitivement fixée lorsque l'utilisateur relâche le bouton gauche de la souris. A ce moment, le dernier dessin intermédiaire est effacé, le dessin définitif est effectué et la souris capturée est libérée.

Le message que reçoit la fenêtre lorsque le bouton gauche de la souris est relâché est wm_LButtonUp; les opérations ci-dessus seront donc exécutées dans une méthode virtuelle indexée WMLBUTTONUP :

Procedure tFenetrePrincipale.WMLBUTTONUP (var Msg : tMessage);
(* Relâchement bouton gauche : fin du dessin et ajout à la liste *)
Var DC : hDC;
    AncienPinceau : hBrush;
    AncienneROP : LongInt;
Begin
  if BoutonEnfonce
     then
       begin
         (* Obtention du DC, sélection pinceau invisible, choix ROP *)
         DC := GetDC(hWindow);
         AncienPinceau := SelectObject(DC,GetStockObject(Hollow_Brush));
         AncienneROP := SetROP2(DC,r2_Not);
         (* Effacement de la forme actuelle *)
         DESSIN_FORME(DC);
         (* Dessin de la forme définitive *)
         DESSIN_FORME(DC);
         (* Libération du DC *)
         SetROP2(DC,AncienneROP);
         SelectObject(DC,AncienPinceau);
         ReleaseDC(hWindow,DC);
         (* Libération de la souris capturée *)
         ReleaseCapture;
         (* Mise à jour indicateur bouton de souris enfoncé *)
         BoutonEnfonce := False;
       end;
End;

Vous voyez que l'indicateur d'enfoncement du bouton gauche de la souris, BoutonEnfonce, est également mis à jour : les mouvements de souris ultérieurs n'entraîneront aucun dessin inopportun de forme.

Lorsque nous avons entamé le présent chapitre, nous avons insisté sur le fait qu'un programme Windows doit mettre à la disposition du système toutes les instructions nécessaires pour redessiner son contenu. Dans le cas présent, nous allons garder en mémoire toutes les formes dessinées par l'utilisateur, pour permettre à Windows de les redessiner en cas de besoin. Pour ce faire, notre programme tiendra à jour une liste chaînée dont chaque élément contiendra les informations nécessaires au dessin d'une forme. Oh, il n'y a en fait pas besoin de beaucoup de renseignements :

• Le type de forme (rectangle, ellipse ou ligne)
• Les coordonnées de début (x1,y1)
• Les coordonnées de fin (x2,y2)

La déclaration de type de la liste chaînée sera toute simple :

Type pForme = ^tForme;
     tForme = Record
                x1, y1, x2, y2 : LongInt;   (* Coordonnées *)
                Forme : LongInt;            (* Type de forme *)
                pSuiv : pForme;             (* Adresse forme suivante *)
              end;

L'endroit où, fort logiquement, une nouvelle forme sera ajoutée à la liste chaînée est l'endroit où celle-ci est définitivement fixée, c'est-à-dire la méthode WMLBUTTONUP :

Procedure tFenetrePrincipale.WMLBUTTONUP (var Msg : tMessage);
(* Relâchement bouton gauche : fin du dessin et ajout à la liste *)
Var ...
    p : pForme;
Begin
  if BoutonEnfonce
     then
       begin
         ...
         (* Ajout de la forme dans la liste chaînée *)
         New(p);
         if p <> Nil
            then
              begin
                p^.x1 := x1;
                p^.y1 := y1;
                p^.x2 := x2;
                p^.y2 := y2;
                p^.Forme := FormeCourante;
                p^.pSuiv := Nil;
                if pTeteFormes = Nil
                   then
                     pTeteFormes := p
                   else
                     pQueueFormes^.pSuiv := p;
                pQueueFormes := p;
              end;
       end;
End;

Pour que Windows puisse redessiner toutes les formes de la liste, nous mettons à sa disposition la méthode Paint :

Procedure tFenetrePrincipale.PAINT (PaintDC : hDC; var PaintInfo : tPaintStruct);
(* Dessin de toutes les formes de la liste *)
Var x1Sauve, y1Sauve, x2Sauve, y2Sauve, FormeSauve : Integer;
    p : pForme;
    AncienPinceau : hBrush;
    AncienneROP : LongInt;
Begin
  (* Sauvegarde des champs *)
  x1Sauve := x1;
  y1Sauve := y1;
  x2Sauve := x2;
  y2Sauve := y2;
  FormeSauve := FormeCourante;
  (* Sélection d'un pinceau invisible, choix ROP *)
  AncienPinceau := SelectObject(PaintDC,GetStockObject(Hollow_Brush));
  AncienneROP := SetROP2(PaintDC,r2_Not);
  (* Dessin de toutes les formes de la liste *)
  p := pTeteFormes;
  while p <> Nil do
    begin
      x1 := p^.x1;
      y1 := p^.y1;
      x2 := p^.x2;
      y2 := p^.y2;
      FormeCourante := p^.Forme;
      DESSIN_FORME(PaintDC);
      p := p^.pSuiv;
    end;
  (* Restauration du DC dans son état d'origine *)
  SetROP2(PaintDC,AncienneROP);
  SelectObject(PaintDC,AncienPinceau);
  (* Restauration des champs *)
  x1 := x1Sauve;
  y1 := y1Sauve;
  x2 := x2Sauve;
  y2 := y2Sauve;
  FormeCourante := FormeSauve;
End;

La technique utilisée pour le dessin est rigoureusement identique à celle des méthodes WMMOUSEMOVE et WMLBUTTONUP. La liste chaînée des formes est entièrement passée en revue et chacune d'elles est redessinée.

L'utilisateur a la possibilité d'effacer à tout moment toutes les formes qui ont été dessinées jusque là, soit en sélectionnant le menu Commandes --> Supprimer tout, soit en pressant la touche Suppr. Dans les deux cas, le message de commande cm_Supprimer est envoyé à la fenêtre du programme, qui y répond au travers de la méthode WMCOMMAND :

Procedure tFenetrePrincipale.WMCOMMAND (var Msg : tMessage);
(* Réponse aux messages de commandes *)
Begin
  case LoWord(Msg.wParam) of
    cm_Supprimer : if not BoutonEnfonce
                      then   (* Suppression de la liste des formes *)
                        begin
                          InvalidateRect(hWindow,Nil,True);
                          DESTRUCTION_LISTE;
                        end;
  else
    tWindow.WMCOMMAND(Msg);
  end;
End;

L'effacement de la fenêtre est effectué par la fonction InvalidateRect, qui a été vue dans le chapitre sur la création des ressources. Parallèlement, il ne faudra plus que Windows redessine les formes qui viennent d'être effacées; la liste chaînée des formes est donc purgée par la méthode DESTRUCTION_LISTE.

Important : cette même méthode devra également impérativement être appelée à la fin du programme, pour détruire la liste chaînée des formes ! C'est dans le destructeur de la fenêtre principale que ce dernier nettoyage aura lieu :

Destructor tFenetrePrincipale.DONE;
(* Destruction de la liste chaînée des formes en fin de programme *)
Begin
  DESTRUCTION_LISTE;
  tWindow.DONE;
End;

Rien de transcendant à se mettre sous la dent au niveau des ressources : un menu.

Voici le source du fichier SHOWIMG.RC :

#include "showimg.inc"
id_MenuPrincipal MENU 
{
 POPUP "&Fichier"
 {
  MENUITEM "&Ouvrir", cm_FileOpen
  MENUITEM SEPARATOR
  MENUITEM "&Quitter", cm_Exit
 }
 POPUP "&Zoom"
 {
  MENUITEM "&50 %", cm_50pc
  MENUITEM "&100 %", cm_100pc
  MENUITEM "&200 %", cm_200pc
  MENUITEM SEPARATOR
  MENUITEM "&Ajuster à la fenêtre", cm_Ajuster
 }
 POPUP "&Aspect"
 {
  MENUITEM "SrcCopy", cm_SrcCopy
  MENUITEM "SrcPaint", cm_SrcPaint
  MENUITEM "SrcAnd", cm_SrcAnd
  MENUITEM "SrcInvert", cm_SrcInvert
  MENUITEM "SrcErase", cm_SrcErase
  MENUITEM "NotSrcCopy", cm_NotSrcCopy
  MENUITEM "NotSrcErase", cm_NotSrcErase
  MENUITEM "MergeCopy", cm_MergeCopy
  MENUITEM "MergePaint", cm_MergePaint
  MENUITEM "PatCopy", cm_PatCopy
  MENUITEM "PatPaint", cm_PatPaint
  MENUITEM "PatInvert", cm_PatInvert
  MENUITEM "DstInvert", cm_DstInvert
  MENUITEM "Blackness", cm_Blackness
  MENUITEM "Whiteness", cm_Whiteness
 }
}

Et à présent le fichier SHOWIMG.INC :

const
        cm_FileOpen      = 24330;
        cm_Exit          = 24340;
        id_MenuPrincipal = 1;
        id_Accel         = 2;
        cm_100pc         = 102;
        cm_200pc         = 103;
        cm_50pc          = 101;
        cm_Ajuster       = 104;
        cm_SrcCopy       = 201;
        cm_SrcPaint      = 202;
        cm_SrcAnd        = 203;
        cm_SrcInvert     = 204;
        cm_SrcErase      = 205;
        cm_NotSrcCopy    = 206;
        cm_NotSrcErase   = 207;
        cm_MergeCopy     = 208;
        cm_MergePaint    = 209;
        cm_PatCopy       = 210;
        cm_PatPaint      = 211;
        cm_PatInvert     = 212;
        cm_DstInvert     = 213;
        cm_Blackness     = 214;
        cm_Whiteness     = 215;

Windows met à la disposition du programmeur une panoplie de dialogues standards, que l'on retrouve dans de très nombreuses applications : dialogues d'ouverture ou d'enregistrement de fichier, dialogues de choix de couleur ou de police de caractères, dialogue de recherche de texte, dialogue d'impression.
Les fonctions de création des dialogues standards sont déclarés dans l'unité CommDlg de Virtual Pascal.

Dans le présent programme, nous avons besoin du dialogue d'ouverture de fichier et de la fonction qui le crée, GetOpenFileName :

Function GetOpenFileName (var OpenFile : tOpenFilename) : Bool;

Un seul paramètre pour cette fonction, de type tOpenFileName :

type pOpenFileName = ^tOpenFileName;
     tOpenFileName = Packed record
                       lStructSize : DWord;
                       hwndOwner : hWnd;
                       hInstance : hInst;
                       lpstrFilter : pChar;
                       lpstrCustomFilter : pChar;
                       nMaxCustFilter : DWord;
                       nFilterIndex : DWord;
                       lpstrFile : pChar;
                       nMaxFile : DWord;
                       lpstrFileTitle : pChar;
                       nMaxFileTitle : DWord;
                       lpstrInitialDir : pChar;
                       lpstrTitle : pChar;
                       Flags : DWord;
                       nFileOffset : SmallWord;
                       nFileExtension : SmallWord;
                       lpstrDefExt : pChar;
                       lCustData : DWord;
                       lpfnHook : tOFNHookProc;
                       lpTemplateName : pChar;
                     end;

Windows permet beaucoup de souplesse dans l'utilisation de ses dialogues standards : on peut mettre le titre que l'on veut, on peut choisir de masquer ou d'afficher certains contrôles, on peut même en remplacer l'aspect ou le comportement général. Dans le cadre de ce tutoriel, nous n'allons pas exploiter toutes les possibilités du dialogue d'ouverture de fichier. Voici les champs qui nous intéressent :

• lStructSize : c'est la taille totale de la structure
• hWndOwner est le handle de la fenêtre qui exécute le dialogue
• lpstrFilter est un ou plusieurs filtre(s) sur les extensions de fichiers
• nFilterIndex est l'index du filtre à utiliser au démarrage
• lpstrFile recevra le chemin complet du fichier choisi par l'utilisateur
• nMaxFile est la taille du buffer lpstrFile
• lpstrFileTitle recevra le nom seul du fichier choisi
• nMaxFileTitle est la taille du buffer lpstrFileTitle
• lpstrinitialDir est le dossier courant au démarrage du dialogue
• Flags est une combinaison or de plusieurs options
• nFileOffset recevra l'index du nom de fichier dans le buffer lpstrFile

Le dialogue d'ouverture de fichier est exécuté lorsque l'utilisateur sélectionne le menu Fichier --> Ouvrir. Nous avons affecté à cette commande l'identificateur cm_FileOpen, que nous avons listé avec tous les identificateurs standards de Windows.

L'ouverture de fichier aura lieu dans une méthode WMCOMMAND :

Procedure tFenetrePrincipale.WMCOMMAND (var Msg : tMessage);
(* Réponse aux messages de commandes *)
Var OFN : tOpenFileName;                        (* Structure du dialogue GetOpenFileName *)
    Chemin : Array [0..Max_Path] of Char;       (* Résultat du dialogue *)
    NomFichier : Array [0..Max_Path] of Char;   (* Nom seul du fichier *)
    Titre : Array [0..Max_Path + 12] of Char;   (* Titre de la fenêtre *)
Begin
  case LoWord(Msg.wParam) of
    cm_FileOpen : begin   (* Ouverture d'un fichier image *)
                    FillChar(OFN,SizeOf(OFN),0);
                    (* Taille de la structure *)
                    OFN.lStructSize := SizeOf(OFN);
                    (* Handle fenêtre parent *)
                    OFN.hWndOwner := hWindow;
                    (* Filtre d'affichage des fichiers *)
                    OFN.lpstrFilter := OFNFiltre;
                    OFN.nFilterIndex := 1;
                    (* Résultat retourné par le dialogue *)
                    Chemin[0] := #0;
                    OFN.lpstrFile := Chemin;
                    OFN.nMaxFile := SizeOf(Chemin);
                    (* Nom seul du fichier retourné par le dialogue *)
                    OFN.lpstrFileTitle := NomFichier;
                    OFN.nMaxFileTitle := SizeOf(NomFichier);
                    (* Dossier de démarrage *)
                    if StrLen(OFNDossier) > 0
                       then
                         OFN.lpstrInitialDir := OFNDossier
                       else
                         OFN.lpstrInitialDir := Nil;
                    (* Flags *)
                    OFN.Flags := ofn_PathMustExist or ofn_FileMustExist or ofn_HideReadOnly;
                    (* Affichage du dialogue *)
                    if GetOpenFileName(OFN)
                       then
                         begin
                           (* Sauvegarde du dossier pour prochaine fois *)
                           StrCopy(OFNDossier,Chemin);
                           OFNDossier[OFN.nFileOffset] := #0;
                           
                           { Chargement de l'image }

                         end;
                  end;
  else
    tWindow.WMCOMMAND(Msg);
  end;
End;

Pour le confort de l'utilisateur, nous décidons de mémoriser dans quel dossier le fichier est ouvert, de manière à lui proposer directement ce dossier lors de l'ouverture suivante. Nous déclarons à cet effet le champ OFNDossier dans l'objet fenêtre principale. Au sujet de la taille de cette chaîne, rappelez-vous que nous avons déjà utilisé la constante Max_Path dans le chapitre sur l'unité WinCRT.

Un autre champ, OFNFiltre, contient le filtre utilisé par le dialogue pour n'afficher que les fichiers d'un ou plusieurs type particuliers. En effet, notre programme ne sera capable de charger que des images bitmaps; il est donc inutile voire idiot de laisser l'utilisateur essayer de charger un fichier JPG, par exemple, si ce format n'est pas supporté ! La meilleure manière d'empêcher cela est de faire en sorte que seuls les fichiers d'extension BMP apparaissent dans le dialogue, donc de définir un filtre.

Le champ lpstrFilter de la structure tOpenFileName est d'un format très spécial : il s'agit d'une liste de couples de sous-chaînes séparées par des 0 (le caractère #0). Chaque couple est constitué d'une description, qui est affichée par le dialogue, et d'un filtre. Les deux sont également séparés par un 0. Le filtre peut être un nom de fichier ou un joker avec une extension et, s'il y en a plusieurs, ils sont séparés par un point-virgule. La chaîne doit se terminer par un double 0.

Dans notre programme, nous définissons le filtre une fois pour toutes dans le constructeur Init de la fenêtre principale :

  StrCopy(OFNFiltre,'Bitmaps (*.bmp)|*.bmp|');
  for i := 0 to StrLen(OFNFiltre) do
    if OFNFiltre[i] = '|'
       then
         OFNFiltre[i] := #0;

Il est difficile de jouer avec des caractères #0 dans les chaînes AZT, puisqu'il s'agit du caractère terminal. Pour contourner le problème, nous remplaçons les #0 par un autre caractère (ici, la barre verticale) et, in fine, nous faisons une boucle pour remplacer ce caractère par un 0.

Le filtre utilisé dans notre programme est évidemment très simple. Pour illustrer les explications ci-dessus, voici un exemple de filtre plus complexe composé de trois sous-filtres (fichier images, fichiers textes et... tous les fichiers) :

  StrCopy(OFNFiltre,'Fichiers images|*.bmp;*.pcx;*.jpg|Fichiers textes|*.txt|Tous les fichiers|*.*|');
  for i := 0 to StrLen(OFNFiltre) do
    if OFNFiltre[i] = '|'
       then
         OFNFiltre[i] := #0;

Une dernière chose à présent : la structure tOpenFileName admet toute une série de flags, que vous pouvez découvrir dans le SDK. Voici ceux que nous utilisons dans notre programme :

• ofn_PathMustExist oblige de retourner un chemin valide
• ofn_FileMustExist oblige de retourner un fichier existant
• ofn_HideReadOnly cache une case à cocher inutile permettant d'ouvrir un fichier en lecture seule

Une fois que la fonction GetOpenFileName se termine avec succès (elle renvoie un booléen), le chemin complet du fichier à charger se trouve dans la variable locale Chemin.
Pour le chargement de l'image, nous allons profiter de la possibilité accordée par la fonction LoadImage d'aller chercher cette image dans un fichier - uniquement dans un fichier BMP. Voici la déclaration de cette fonction :

Function LoadImage (hInst : hInst; ImageName : pChar; ImageType : UInt; X, Y : Integer; Flags : UInt) : tHandle;

• hInst est le handle d'instance du module qui contient l'image (0 pour un fichier)
• ImageName est le nom de l'image ou, dans notre cas, le nom du fichier
• ImageType identifie le type d'image : Image_Bitmap, Image_Cursor ou Image_Icon
• X et Y sont la largeur et la hauteur, uniquement pour un curseur ou une icône
• Flags permet de définir les options de chargement (lr_LoadFromFile dans notre cas)

La valeur retournée par la fonction est le handle de l'image, qui vaudra 0 si une erreur s'est produite. Nous écrivons donc dans notre programme :

                    if GetOpenFileName(OFN)
                       then
                         begin
                           (* Sauvegarde du dossier pour prochaine fois *)
                           StrCopy(OFNDossier,Chemin);
                           OFNDossier[OFN.nFileOffset] := #0;
                           (* Chargement de la nouvelle image *)
                           hImage := LoadImage(0,Chemin,Image_Bitmap,0,0,lr_LoadFromFile);
                           if hImage <> 0
                              then
                                begin

                                  { Affichage de l'image }
                                  
                                end
                              else   (* Erreur *)
                                MessageBox(hWindow,'Impossible de charger l''image','Erreur',mb_IconHand or mb_Ok);

Vous trouverez sans doute que le programme est très limité, puisqu'il ne permet de charger que des images au format BMP. C'est volontaire, puisque le but de ce chapitre est de se familiariser avec l'interface GDI. Rien ne vous empêche de développer des routines de chargement d'images dans d'autres formats !

La plupart des applications Windows qui permettent de charger des fichiers affichent le nom de ce fichier dans la barre de titre. Nous n'allons pas déroger à cette règle; c'est pourquoi nous récupérons le nom du fichier chargé dans la variable locale NomFichier, qui est passée comme paramètre lpstrFileTitle de la structure tOpenFileName. Dans la barre de titre, nous afficherons le nom du fichier entre crochets, à la suite du nom de l'application.

La fonction SetWindowText permet de définir le titre de la fenêtre :

Function SetWindowText (Wnd : hWnd; Str : pChar) : Bool;

Sont passés comme paramètres le handle de la fenêtre et le titre.

Donc, si le chargement de l'image s'est bien déroulé alors nous afficherons le nom du fichier entre crochets dans la barre de titre, sinon nous n'affichons que le nom de l'application :

                           hImage := LoadImage(0,Chemin,Image_Bitmap,0,0,lr_LoadFromFile);
                           if hImage <> 0
                              then
                                begin
                                  (* Titre de la fenêtre *)
                                  StrCopy(Titre,NomApplication);
                                  StrCat(Titre,' - [');
                                  StrCat(Titre,NomFichier);
                                  StrCat(Titre,']');
                                  SetWindowText(hWindow,Titre);
                                  
                                  { Affichage de l'image }
                                  
                                end
                              else   (* Erreur *)
                                begin
                                  (* Titre de la fenêtre *)
                                  SetWindowText(hWindow,NomApplication);
                                  (* Message d'erreur *)
                                  MessageBox(hWindow,'Impossible de charger l''image','Erreur',mb_IconHand or mb_Ok);
                                end;

Avant d'aborder le côté technique de l'affichage, parlons un peu des possibilités de l'utilisateur. D'une part, il peut choisir un niveau de zoom : 50%, 100%, 200% ou ajustage de l'image aux dimensions de la fenêtre. Il effectue ce choix dans le menu Zoom et ce choix est mémorisé en stockant l'identificateur de la commande choisie dans le champ Zoom de l'objet fenêtre principale.

D'autre part, il peut choisir dans le menu Aspect une opération logique à appliquer à l'image pour changer son aspect à l'écran L'affichage de l'image chargée en mémoire se fait dans une méthode Paint. Bien entendu, nous devons commencer par tester qu'il y a bien une image en mémoire, en regardant si le champ hImage, qui contient le handle de l'image courante, ne vaut pas 0.

Voici notre méthode Paint :

Procedure tFenetrePrincipale.PAINT (PaintDC : hDC; var PaintInfo : tPaintStruct);
(* Affichage de l'image *)
Var MemDC : hDC;                (* DC compatible *)
    AncienneBitmap : hBitmap;   (* Ancienne bitmap sélectionnée dans MemDC *)
    l, h : LongInt;             (* Largeur et hauteur image à l'écran *)
    Rect : tRect;               (* Coordonnées de la zone client *)
Begin
  if hImage <> 0
     then
       begin
         MemDC := CreateCompatibleDC(PaintDC);
         AncienneBitmap := SelectObject(MemDC,hImage);
         case Zoom of
           cm_50pc : begin   (* Zoom 50 % *)
                       l := DonneesImage.bmWidth div 2;
                       h := DonneesImage.bmHeight div 2;
                     end;
           cm_100pc : begin   (* Zoom 100 % *)
                        l := DonneesImage.bmWidth;
                        h := DonneesImage.bmHeight;
                      end;
           cm_200pc : begin   (* Zoom 200 % *)
                        l := DonneesImage.bmWidth * 2;
                        h := DonneesImage.bmHeight * 2;
                      end;
           cm_Ajuster : begin   (* Ajuster à la taille fenêtre *)
                          GetClientRect(hWindow,Rect);
                          l := Rect.Right;
                          h := Rect.Bottom;
                        end;
         end;
         StretchBlt(PaintDC,0,0,l,h,MemDC,0,0,DonneesImage.bmWidth,DonneesImage.bmHeight,Aspects[Aspect]);
         SelectObject(MemDC,AncienneBitmap);
         DeleteDC(MemDC);
       end;  
End;