Les génériques sous Delphi.NET

Procédure

Description

ReWrite

Crée et ouvre un nouveau fichier. Tout fichier existant portant le meme nom sera écrasé

WriteLn

Ecrit une ligne de texte dans le fichier ouvert, en ajoutant en bout de ligne une combinaison CR/LF (retour chariot / saut de ligne)

CloseFile

Finit la mise à jour du fichier courant et referme ce dernier

Procédure

Description

Reset

Ouvre un fichier existant. Les fichiers texte sont ouverts en lecture seule

Readln

Lit la ligne de texte courant dans un fichier de texte ouvert. Chaque ligne s’achève par une combinaison CR/LF.

FICHIERS BINAIRES

FICHIERS TYPÉS

Erase

Supprime un fichier

FileSize

Donne la taille du fichier spécifié

GetDir

Donne le répertoire courant du lecteur spécifié

MkDir

Crée un sous – répertoire

Rename

Renomme un fichier

RmDir

Supprime un sous – répertoire

Nom long

Nom court

Function ChangeFileExt ( const Fichier, Extension: string ) :string ;

Function FileAge (const Fichier : string) : Longint ;

function FileAge(const FileName: string): Integer;

Description

La fonction FileAge renvoie l'âge du fichier FileName sous la forme d'un Integer. La valeur renvoyée est -1 si le fichier n'existe pas.

Function FileCreate ( const Fichier: string ) : Integer;

FileCreate crée un nouveau fichier.

function FileCreate(const FileName: string): Integer;

Description

La fonction FileCreate crée un nouveau fichier avec le nom spécifié. Si la valeur renvoyée est positive, la fonction s'est bien déroulée et cette valeur correspond au descripteur du nouveau fichier. Si la valeur renvoyée vaut -1, cela indique qu'une erreur s'est produite.

L'utilisation de gestionnaires de variables de fichier Pascal non natif tels que FileCreate est déconseillée. Pour plus d'informations sur l'utilisation des routines de gestion de fichier, voir FileOpen.

Function FileOpen ( const Fichier: string ) : Integer;

FileOpen ouvre un fichier en utilisant le mode d'accès spécifié.

function FileOpen(const FileName: string; Mode: Integer): Integer;

Description

La valeur du mode d'accès résulte d'un OU logique entre une des constantes fmOpenXXXX avec une des constantes fmShareXXXX. Si la valeur renvoyée est positive, la fonction s'est bien déroulée et la valeur représente le descripteur du fichier ouvert. Si la valeur renvoyée vaut -1, cela indique qu'une erreur s'est produite.

Remarque

L'utilisation de gestionnaires de variables de fichiers Pascal non natif tels que FileOpen est déconseillée. Ces routines sont identiques aux fonctions de l'API Windows en ce sens qu'elles renvoient les descripteurs de fichiers et non les variables de fichier Pascal classique. Ces dernières sont des routines d'accès aux fichiers de bas niveau. Pour des opérations sur des fichiers classiques, utilisez les fonctions AssignFile, Rewrite, Reset au lieu de FileOpen.

Function FileExists (const Fichier : string) : Boolean ;

FileExists teste si FileName existe.

Description

La fonction FileExists renvoie True si le fichier FileName existe. Dans le cas contraire, FileExists renvoie False.

Function FileGetAttr ( const Fichier : string) : Integer;

FileGetAttr renvoie les attributs du fichier FileName.

function FileGetAttr(const FileName: string): Integer;

Description

Ces attributs peuvent être récupérés à l'aide de l'opérateur ET (AND) et des constantes définies dans TsearchRec (faXXXXX). Une erreur s'est produite si la valeur renvoyée est -1. Les constantes pouvant être utilisées pour tester la valeur renvoyée sont :

                Constante      Valeur            Description

 On peut combiner les attributs de fichier en ajoutant leurs constantes ou valeurs. Par exemple, pour rechercher des fichiers cachés et en lecture seule en plus des fichiers normaux, on peut utiliser le masque ( faReadOnly + faHidden ).

FileSearch recherche un fichier dans le chemin DOS spécifié.

function FileSearch(const Name, DirList: string): string;

Description

La fonction FileSearch recherche dans les répertoires transmis par DirList un fichier intitulé Name. DirList doit respecter le format d'un chemin d'accès DOS : les noms de répertoire doivent être séparés par des points-virgules. Si FileSearch localise un fichier correspondant à Name, elle renvoie une chaîne contenant le chemin d'accès développé à ce fichier. Si aucune correspondance n'est trouvée, FileSearch renvoie une chaîne vide.

 Exemple  :

Function FileSetAttr ( const Fichier: string ; Attr : Integer) :Integer ;

FileSetAttr définit les attributs du fichier spécifié.

function FileSetAttr(const FileName: string; Attr: Integer): Integer;

Description

La fonction FileSetAttr définit les attributs du fichier FileName à partir de la valeur transmise par Attr. La valeur d'attribut est constituée en faisant appel à l'opérateur OU et aux constantes faXXXX appropriées. La valeur renvoyée est zéro si l'exécution de la fonction réussit. Sinon, cette valeur est un code d'erreur Windows.

Function FileSize (var F): Longint;

FileSize renvoie la taille d'un fichier (en octets) ou le nombre d'enregistrements dans le fichier. function FileSize(var F): Integer;

Description

La fonction FileSize renvoie la taille en octets du fichier F. Pour utiliser FileSize, le fichier doit être ouvert. F est une variable fichier. Si le fichier est vide, FileSize(F) renvoie 0.

Remarque FileSize ne peut être utilisée avec un fichier texte.

 Exemple  :

var       f: file of Byte;             size : Longint;          S: string;

             y: integer;  begin

            if OpenDialog1.Execute then begin

                                        AssignFile(f, OpenDialog1.FileName);

                                        Reset(f);

                                        size := FileSize(f);

                                        S := 'Taille du fichier en octets: ' + IntToStr(size);

                                        y := 10;

             Canvas.TextOut(5, y, S);      y := y + Canvas.TextHeight(S) + 5;      S := 'Positionnement au milieu du fichier ';

y := y + Canvas.TextHeight(S) + 5;

                                        Seek(f,size div 2);

                                        S := 'Position actuelle: ' + IntToStr(FilePos(f));

             Canvas.TextOut(5, y, S);      CloseFile(f);    end;

 end;

Function RenameFile(const AncienNom, NouveauNom: string): Boolean;

RenameFile renomme le fichier identifié par OldName.

function RenameFile(const OldName, NewName: string): Boolean;

Description

La fonction RenameFile tente de changer le nom du fichier indiqué de OldFile en NewFile. Si l'opération réussit, RenameFile renvoie True. Si le fichier n'a pas pu être renommé (si, par exemple, un fichier intitulé NewName existe déjà), la fonction renvoie False. Le code suivant renomme un fichier :

if not RenameFile('','') then

                            ErrorMsg('Erreur de renommage de fichier');

IMPRIMER

Bien que nous vivions dans un monde de plus en plus électronique, dans lequel nous utilisons télécopie, messages électroniques et logiciels de présentation, il vient toujours un moment où il est nécessaire d’imprimer du texte ou un graphique venant d’un programme, pour générer des formulaires ou des brochures par exemple.

BASES DE L’IMPRESSION EN PASCAL

Si vous connaissez déjà les techniques d’impression en Pascal ou dans d’autres langages, vous ne serez pas surpris. L’impression dans sa plus simple expression consiste à créer une variable de fichier et à l’affecter à l’imprimante. Vous utilisez alors une déclaration writeln pour envoyer le texte vers l’imprimante. Ce type d’impression est des plus primitifs comparé aux fonctionnalités dont vous disposez dans Windows, mais il suffit parfois amplement. Imaginez par exemple qu’un ordinateur est connecté à une imprimante texte qui permet d’obtenir des sorties papier des mesures d’un instrument. Ou que vous souhaitez imprimer une liste simple, sans avoir besoin d’utiliser de graphiques, de polices et sans formatage particulier.

Le code ci-après utilise une déclaration writeln pour imprimer :

var

P : TextFile; begin

AssignPrn(P); rewrite(P);

writeln(P,’Test d’’impression’);

CloseFile(P); end;

Comme vous pouvez le voir, on déclare une variable P de type TextFile. On utilise ici une variante de Assign, AssignPrn. Cette fonction affecte la variable au port de l’imprimante, le traitant comme un fichier. Il faut ensuite ouvrir le port de l’imprimante et on utilise rewrite à cet effet. Le texte est envoyé à l’imprimante par le biais de la procédure writeln et le port de l’imprimante est fermé avec CloseFile. Il est important de fermer le port de l’imprimante pour terminer l’opération. Tout texte restant encore en mémoire est envoyé vers l’imprimante et le port est fermé, tout comme un fichier.

IMPRIMER AVEC L’OBJET TPRINTER DE DELPHI

La place nous manque pour décrire en détail toutes les propriétés et méthodes des objets imprimante. Dans cette partie, nous développerons quelques programmes donnant des exemples d’utilisation des objets imprimante. Vous verrez ainsi comment doter vos applications de fonctionnalités d’impression.

Printer : Tprinter;

Pour utiliser l’objet TPrinter, vous devez ajouter l’unité Printers à la clause uses de votre code. A la différence d’autres unités usuelles, Printers n’est pas ajouté d’office par Delphi.

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls,Printers;

Cela fait, vous pouvez utiliser Printer pour référencer des propriétés dans l’objet TPrinter.

Avant de pouvoir utiliser l’objet TPrinter, vous devez connaître certaines de ses propriétés et méthodes :

PageNumber Renvoie le numéro de la page actuellement imprimée.

Ainsi, si vous souhaitez imprimer du texte à l’aide de l’objet Printer, vous écrirez quelque chose comme :

Printer.BeginDoc;

Printer.Canvas.TextOut(10,10,‘J’’imprime avec l’’objet Printer’); Printer.EndDoc;

Ce code provoque l’impression du texte J’imprime avec l’objet Printer à partir du dixième pixel à droite et du dixième pixel en partant du haut du canevas. BeginDoc lance l’impression. Le texte est envoyé au canevas à l’aide de la propriété TextOut du canevas. EndDoc déclenche l’impression du texte proprement dite et termine la tâche d’impression.

COMPOSANTS DE GESTION DE L’IMPRESSION

Vous avez sans doute vu des logiciels du commerce qui utilisent des boîtes de dialogue pour sélectionner des options d’impression telles que le nombre de copies, le rassemblement de copies et l’orientation de la page. Il n’est pas difficile avec Delphi d’obtenir ces fonctions. Il vous suffit de placer le composant TPrinterDialog sur la page et d’ajouter quelques lignes de code. Votre application dispose alors de boîtes de dialogue Impression. Le code qui le permet est le suivant :

if PrintDialog1.Execute then

Begin

{votre code d’impression} end;

Lorsque ce code est exécuté, la boîte de dialogue Impression standard de Windows apparaît, permettant à l’utilisateur de sélectionner des options pour la tâche d’impression en attente. Ces sélections faites, la tâche d’impression est menée à bien en tenant compte des paramètres spécifiés (sauf pour le nombre de copies, pour lequel il est nécessaire de créer une boucle). Ce n’est pas plus compliqué que ça.

IMPRIMER DES GRAPHIQUES

Vous avez imprimé du texte en utilisant la méthode traditionnelle et vous avez également envoyé du texte par le biais de l’objet TPrinter. Mais qu’en est-il des représentations graphiques ? Vous désirez peut-être créer des logos, des graphiques et d’autres informations non textuelles. Dans cette partie, nous verrons comment imprimer pratiquement n’importe quel graphique. Vous n’êtes en fait limité que par l’imprimante que vous utilisez.

Prenons un exemple. Le code ci-après trace un cercle dans le coin supérieur gauche de la fiche Form1 :

begin

{Définit une épaisseur de crayon de 5 pixels }

.Width:=5;

{Dessine une ellipse dont le coin supérieur gauche est à 0,0 et le coin inférieur droit à 200,200}

Form1.Canvas.Ellipse(0, 0, 200, 200); end;

Le code suivant dessine le même cercle, au même emplacement sur le canevas de TPrinter et l’envoie à l’imprimante :

begin

{début de la tâche d’impression }

Printer.BeginDoc;

{ Définit une épaisseur de crayon de 5 pixels }

.Width:=5;

{ Dessine une ellipse dont le coin supérieur gauche est à 0,0 et le coin inférieur droit à 200,200}

Printer.Canvas.Ellipse(0, 0, 200, 200);

{fin et impression de la tâche d’impression }

Printer.EndDoc; end;

En ajoutant les lignes BeginDoc et EndDoc, et en transformant Form1 en Printer pour pointer vers le canevas de l’imprimante plutôt que celui de la fiche, vous pouvez envoyer le même graphique à l’imprimante.

Page 68 sur 370

GDI ET PROGRAMMATION GRAPHIQUE

Delphi propose de nombreuses fonctions permettant de créer facilement des applications graphiques. Dans ce chapitre, nous vous présenterons la base de la création d’applications graphiques et vous montrerons comment utiliser des techniques graphiques et multimédias sophistiquées.

COORDONNÉES

Vous savez sans doute ce que sont des coordonnées. Tous les composants visuels ont une propriété Top (haut) et une propriété Left (gauche). Les valeurs stockées dans ces propriétés déterminent la position du composant sur la fiche. Autrement dit, le composant est placé aux coordonnées X, Y, où X est la propriété Left et Y la propriété Top. Les valeurs en X et Y (ou Left et Top) sont exprimées en pixels. Un pixel est la plus petite zone d’écran manipulable.

PROPRIÉTÉ CANVAS

La propriété Canvas est la zone de dessin sur une fiche et sur d’autres composants graphiques; elle permet au code Delphi de manipuler la zone de dessin en cours d’exécution. L’une de ses principales caractéristiques est qu’elle est constituée de propriétés et de méthodes facilitant la manipulation de graphiques dans Delphi. Toutes les manipulations formelles et les comptabilités diverses sont cachées dans l’implémentation de l’objet Canvas.

La partie suivante présente les fonctions de base vous permettant d’effectuer des opérations graphiques dans Delphi à l’aide de l’objet Canvas.

D’un point de vue conceptuel, toutes les opérations graphiques reviennent à définir la couleur des pixels de la surface de dessin. En Delphi, vous pouvez manipuler les pixels individuellement.

Aux débuts de l’informatique, un pixel était soit activé, soit désactivé, il était donc noir ou blanc (ou vert ou ambre). Les pixels peuvent maintenant prendre une vaste gamme de couleurs. Leur couleur peut être spécifiée soit comme une couleur prédéfinie, telle que clBlue, soit comme un mélange arbitraire des trois couleurs rouge, vert et bleu.

UTILISER DES PIXELS

Dans l’exemple suivant, nous utilisons la propriété Pixels pour dessiner une courbe de sinus dans la fiche principale. Le seul composant de la fiche est un bouton qui dessine la courbe lorsqu’on clique dessus. Nous utilisons les paramètres Width (largeur) et Height (hauteur) de la fiche afin que la courbe prenne place sur 70 % de la hauteur de la fiche et sur l’ensemble de la longueur.

unit unitSine; interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls;

type

TForm1 = class(TForm) DrawSine: TButton;

procedure DrawSineClick(Sender: TObject);

private

{ Déclarations privées } public

{ Déclarations publiques } end;

var

Form1: TForm1;

implementation {$R *.DFM}

procedure TForm1.DrawSineClick(Sender: TObject); var

X, Y : real;

PX, PY, HalfHeight : longint;

begin

{ On détermine la moitié inférieure de la fiche }

HalfHeight := Form1.Height div 2;

for PX:=0 to Form1.Width do

BEGIN

{On met à l’échelle X en fonction de 2 PI pour décrire une période }

X := PX * (2*PI/Form1.Width);

Y := sin(X);

PY := trunc(0.7 * Y * HalfHeight) + HalfHeight;

{On rend le pixel noir (0 d’intensité RVB)}

Canvas.Pixels[PX,PY] := 0;

END;

end; end.

Dans cette application, on commence par déterminer la hauteur de la fiche afin d’échelonner correctement la sinusoïde. Le compteur PX va ensuite de 0 à la largeur de la fiche, et une valeur Y est calculée en chaque point de la sinusoïde. La coordonnée Y est multipliée par un facteur d’échelle afin que la courbe soit bien placée sur la fiche. Le point est dessiné en définissant la propriété Canvas.Pixel.

MoveTo.

La ligne de code ci-après déplace le crayon jusqu’aux coordonnées 23,56.

Form1.Canvas.MoveTo(23,56);

Pour tracer une ligne droite allant de la position actuelle du crayon jusqu’à une autre position, il suffit d’utiliser la méthode LineTo. LineTo n’a besoin que des coordonnées de la destination du crayon, et trace alors une ligne droite de la position actuelle jusqu’à la nouvelle.

La procédure suivante utilise la propriété LineTo pour dessiner un motif original.

procedure TForm1.DrawSineClick(Sender: TObject); var

X, Y : real;

PX, PY, Offset, HalfHeight : longint;

begin

{ On détermine les coordonnées de la moitié inférieure de la fiche }

HalfHeight := Form1.Height div 2;

For OffSet := -10 to 10 do

BEGIN

PX := 0;

While PX < Form1.Width do

BEGIN

X := PX * (2*PI/Form1.Width);

Y  := sin(X);

PY := trunc(0.7 * Y * HalfHeight)+HalfHeight + (Offset *10);

IF (PX = 0) Then canvas.MoveTo(PX,PY);

canvas.LineTO(PX,PY);

PY := trunc(0.7*Y*HalfHeight)+HalfHeight+((Offset-1) *10); canvas.LineTO(PX,PY);

PX := PX +15;

END;

END;

end; end.

Ce programme est presque identique à celui du tracé de courbe sinus, à ceci près qu’ici nous créons des interstices entre les points, que nous connectons ensuite avec des lignes. Lors de la première itération (lorsque PX=0), on utilise la méthode MoveTo pour aller au premier point. Il nous suffit ensuite d’utiliser MoveTo pour nous déplacer vers tous les points suivants.

Vous passez à la fonction PolyLine un tableau de point (c’est un concept qui doit vous sembler nouveau). Jusqu’ici, tout se faisait au moyen de coordonnées et vous passiez à la fonction LineTo des valeurs en X et Y.

Delphi comporte un type TPoint, qui encapsule les valeurs en X et Y dans un enregistrement unique appelé point. La façon la plus simple de créer un point consiste à utiliser la fonction Point. Point prend une valeur X et une valeur Y et renvoie en enregistrement TPoint. Vous remarquerez que le premier et le dernier points ne sont pas forcément connectés, vous devez donc en spécifier un dernier identique au premier si vous souhaitez obtenir un polygone fermé.

Ainsi, l’appel au PolyLine suivant trace un rectangle :

Form1.Canvas.PolyLine([Point(10,10),Point(100,100),Point(50,75),Point(10,10)]);

Vous pouvez étendre ce principe pour créer une procédure traçant un polygone symétrique composé d’un nombre arbitraire de côtés entré par l’utilisateur. Si l’utilisateur entre 8, la procédure trace un octogone ; un 6 donne un hexagone. Il suffit d’utiliser des principes simples de géométrie en plaçant les sommets sur un cercle. Le Listing suivant vous montre la source de ce programme.

procedure TForm1.DrawPolyClick(Sender: TObject); var

Sides, Count : integer;

PolyArray : Array[0..15] of TPoint; begin

Sides := strtoint();

If Sides > 15 then Sides := 15; /* Le tableau ne contient que 15 points*/

For Count := 0 to Sides do

BEGIN

{On utilise les points d’un cercle. On choisit des sommets comme points}

PolyArray[Count] := Point(TRUNC(SIN((2*PI)*COUNT/Sides)*

30)+(Form1.Width div 2),TRUNC(COS((2*PI)*COUNT/Sides)* 30)+ (Form1.Height div 2));

END;

{On connecte le dernier point au premier et on définit tous les points restants comme égaux au premier point }

For Count := Sides+1 to 15 do

PolyArray[Count] := PolyArray[0];

{On dessine le polygone}

Form1.Canvas.PolyLine(PolyArray); end;

Toutes les formes tracées jusqu’ici utilisaient le crayon par défaut. Il est possible de changer la couleur, l’épaisseur de trait et le style du crayon. En Delphi, vous accédez au crayon par le biais du canevas, qui dispose d’une propriété Pen. Les principales propriétés par le crayon son Color, Width, Style et Mode.

COLOR

Vous pouvez définir la couleur du crayon en utilisant les mêmes méthodes que pour la couleur de la fiche. Ainsi, pour définir comme bleue la couleur du crayon, procédez ainsi :

.Color := clBlue;

Vous pouvez également utiliser la ligne suivante :

.Color := RGB(0,0,255);

Pour afficher toutes les nuances de gris, utilisez la procédure suivante :

procedure TForm1.DrawGreyClick(Sender: TObject); var

Count : Integer; begin

For Count := 0 to 255 do

BEGIN

.Color := RGB(Count,Count,Count);

Form1.Canvas.MoveTo(Count,0);

Form1.Canvas.LineTo(Count,100); end;

end;

WIDTH ET STYLE

La propriété Width définit la largeur du crayon en pixels. La propriété Style donne au crayon des tracés variés, tels que pointillés ou tirets. Les valeurs valides pour la propriété Style sont psSolid, psDash, psDot, psDashDot, psDashDotDot, psClear et psInsideFrame. Si vous souhaitez un crayon rouge, large de trois pixels et traçant en pointillé, exécutez ce qui suit :

.Color := clRed;

.Width := 3;

.Style := psDot;

MODE

La propriété Mode du crayon lui permet d’interagir avec son environnement. Un mode pmNot, par exemple, fait tracer le crayon dans une couleur inverse de celle du fond (l’inverse de chaque bit par conséquent). Le crayon utilise le mode pmCopy par défaut, lui faisant utiliser la couleur courante. Vous pouvez déterminer la couleur du crayon en regardant la propriété color.

Les étapes suivantes vous montrent ce qu’il se passe.

1.  Le pixel de fond a une valeur de 0110011.

2.  Vous effectuez un Ou exclusif de cette valeur avec 1111000.

3.  Le nouveau pixel a une valeur de 1001011.

Lorsque vous souhaitez effacer le pixel et refaire apparaître le fond, il suffit de reprendre le même procédé :

1.  Le pixel a actuellement pour valeur 1001011.

2.  Vous effectuez un Ou exclusif de cette valeur avec 1111000.

3.  Vous obtenez 0110011 comme résultat (la valeur initiale).

L’avantage de cette méthode est que vous n’avez pas besoin de stocker les informations concernant le fond, elles sont retrouvées automatiquement. L’inconvénient est que vous n’obtenez pas tout à fait l’image souhaitée car vous faites figurer les informations de fond dans la couleur du pixel. Dans la procédure suivante, on utilise cette technique pour animer un triangle se déplaçant sur une fiche. Vous pouvez voir une boîte rouge sur la fiche, le triangle bleu passera sur la boîte sans la modifier.

procedure TForm1.SimpleAnimateClick(Sender: TObject); var

Count : Integer;

Pause : real ; begin

{ On dessine une boîte }

:= pmCopy; .Color := clRed;

Form1.Canvas.PolyLine([point(50,10),point(100,10),point(100,200), point(50,200), point(50,10)]);

{On définit le crayon }

.Color := clBlue;

:= pmNotXor;

For Count := 0 to (Form1.Width div 5) do

BEGIN

{On dessine le triangle }

Form1.Canvas.PolyLine([point(Count*5,100),point(Count*5+10,100, point(Count*5+5,110),point(Count*5,100)]);

Pause := Time; while (Time-Pause) < 1e-12 do; {on ne fait rien}

{On efface le triangle }

Form1.Canvas.PolyLine([point(Count*5,100),point(Count*5+10,100, point(Count*5+5,110),point(Count*5,100)]);

end;

end;

OBJET PINCEAU ET REMPLISSAGE

Au lieu de n’utiliser que les contours, vous pouvez remplir certains des objets proposés par Delphi. La propriété Brush détermine la façon dont un objet est rempli. Les trois propriétés principales affectant le pinceau (brush) sont Color, Style et Bitmap. On peut utiliser le pinceau de deux façons différentes : avec les propriétés Color et Style ou avec la propriété Bitmap.

Lorsque vous utilisez les propriétés Color et Style, la couleur du remplissage dérive de la valeur de la propriété Color. La propriété Style définit le style du remplissage. De la même façon que vous utilisez la méthode PolyLine pour des objets contourés (non remplis), utilisez la méthode Polygon pour dessiner des polygones remplis. L’exemple de programme suivant montre tous les styles disponibles sur huit triangles différents.

procedure Triangle(Iteration : Integer); begin

Form1.Canvas.Brush.Color := clBlue;

Form1.Canvas.Polygon([Point(TRUNC((Iteration/9)*Form1.Width),50),

Point(TRUNC((Iteration/8)*Form1.Width),100),

Point(TRUNC(((Iteration-1)/8)*Form1.Width),100),

Point(TRUNC((Iteration/9)*Form1.Width),50)]); end;

procedure TForm1.ShowTrianglesClick(Sender: TObject); begin

Form1.Canvas.Brush.Style := bsSolid;

Triangle(1);

Form1.Canvas.Brush.Style := bsClear;

Triangle(2);

Form1.Canvas.Brush.Style := bsHorizontal;

Triangle(3);

Form1.Canvas.Brush.Style := bsVertical;

Triangle(4);

Form1.Canvas.Brush.Style := bsFDiagonal;

Triangle(5);

Form1.Canvas.Brush.Style := bsBDiagonal;

Triangle(6);

Form1.Canvas.Brush.Style := bsCross;

Triangle(7);

Form1.Canvas.Brush.Style := bsDiagCross;

Triangle(8); end;

Un bitmap de pinceau est un bitmap de 8 pixels par 8 pixels définissant le motif utilisé pour remplir les objets.

Pour utiliser un bitmap sur un pinceau, vous devez commencer par créer un bitmap, l’affecter, puis le libérer lorsque vous avez terminé. La création et la manipulation des bitmap sont détaillées un peu plus loin.

De même que le type TPoint spécifie un ensemble de coordonnées en Delphi, un type Trect précise une partie rectangulaire dans une zone graphique. Vous spécifiez une région rectangulaire en donnant les coordonnées des coins supérieur gauche et inférieur droit.

La fonction Rect permet de créer un type TRect à partir de coordonnées. La plupart des fonctions manipulant les régions rectangulaires utilisent des types TRect comme paramètres. Ainsi, vous utilisez la méthode FillRect pour dessiner un rectangle rempli. La ligne de code ci-après est un exemple d’utilisation de la méthode FillRect. Remarquez que vous devez utiliser la fonction Rect pour spécifier les coordonnées.

Form1.Canvas.FillRect(Rect(20,20,100,100));

En plus de la procédure FillRect, la procédure Rectangle dessine un rectangle en utilisant les attributs du pinceau courant pour le remplissage et ceux du crayon courant pour les contours. Cependant, cette procédure ne prend pas les mêmes paramètres que la précédente. Les quatre points sont paramètres, et l’on ne passe donc pas un type TRect. La ligne de code ci-après est un exemple d’utilisation de la procédure Rectangle.

Form1.Canvas.Rectangle(20,20,100,100);

Tout ce que vous avez pu tracer jusqu’ici était constitué de points distincts ou de combinaisons de lignes droites. Le monde serait bien morne sans courbes ; Delphi propose différentes méthodes pour tracer des cercles, des ellipses, des arcs et des tranches. Un cercle est une ellipse dont le rayon est constant.

Form1.Canvas.Ellipse(100,100,200,200);

Pour dessiner une ellipse dont la largeur est supérieure à la hauteur, exécutez ce qui suit :

Form1.Canvas.Ellipse(100,100,300,200);

Pour ne dessiner qu’une portion d’ellipse, la procédure est un peu plus complexe. La méthode prend huit paramètres. Les quatre premiers sont nécessaires au tracé d’une ellipse complète. Les deux derniers (en fait quatre) sont les points indiquant le pourcentage de l’ellipse qui apparaîtra. Ils représentent les points d’arrivées des deux lignes partant de l’origine et définissant la portion de courbe à tracer. Ainsi, par exemple, la ligne ci-après trace un quart de cercle.

(100,100,200,200,100,100,100,200);

Un arc est en tout point semblable à une tranche, à cela près qu’il n’est pas rempli. Le code ciaprès affiche un arc de même longueur que la tranche tracée ci-dessus.

(100,100,200,200,100,100,100,200);

TEXTE

Un objet TFont définit l'apparence du texte. Un objet TFont définit un jeu de caractères à partir d'une hauteur, du nom de famille de la fonte (police), etc. La hauteur est indiquée par la propriété Height, la police par la propriété Name, la taille en points par la propriété Size, la couleur par la propriété Color, et les attributs de la fonte (gras, italique, etc.) par la propriété Style.

Lorsqu'une fonte est modifiée, un événement OnChange se produit.

Outre ces propriétés, ces méthodes et ces événements, cet objet dispose de ceux qui s'appliquent à tous les objets. les styles

La propriété Style est un ensemble, elle peut donc contenir plusieurs valeurs. Une fonte peut, par exemple, être en gras et en italique.

procedure TextOut(X, Y: Integer; const Text: string);

TextOut dessine la chaîne contenue dans Text sur le canevas en utilisant la fonte courante, l'angle supérieur gauche du texte se situant au point de coordonnées (X, Y).

Exemple

Cet exemple affiche une chaîne texte à la position indiquée sur la fiche lorsque l'utilisateur clique sur le bouton de la fiche:

procedure TForm1.Button1Click(Sender: TObject); begin

  Canvas.TextOut(20, 20, 'DELPHI facilite la programmation Windows'); end;

 QUELQUES FONCTIONS UTILES  :

TextHeight renvoie la hauteur en pixels de la chaîne transmise par Text telle qu'elle apparaîtrait avec la fonte courante. Il est possible d'utiliser TextHeight pour déterminer si la chaîne entière apparaît dans un espace prédéfini.

Exemple

Cet exemple affiche dans une boîte d'édition de la fiche la hauteur d'une chaîne texte telle qu'elle apparaîtrait sur le canevas avec la fonte courante :

procedure TForm1.FormCreate(Sender: TObject); var

                            L: LongInt;

begin

             L := Canvas.TextHeight('Object Pascal est le meilleur');   := IntToStr(L) + ' est la hauteur en pixels'; end;

La méthode TextWidth renvoie la largeur en pixels de la chaîne transmise par le paramètre Text en supposant son affichage avec la fonte courante. Il est possible d'utiliser TextWidth pour déterminer si une chaîne peut être contenue dans un espace préétabli.

Exemple

Cet exemple détermine la largeur de la chaîne indiquée et, si elle est trop large pour s'afficher dans une boîte d'édition, cette dernière est agrandie pour permettre son affichage en entier. Ensuite, la chaîne est affichée dans la boîte d'édition.

procedure TForm1.Button1Click(Sender: TObject); var

             T: Longint;     S: string; begin

T := Canvas.TextWidth(S);    if T > Edit1.Width then

             Edit1.Width := T + 10;   := S; end;

ONPAINT : POUR REDESSINER UNE FENÊTRE

Autrefois, un programme graphique utilisait tout l’écran et supposait que toute modification à l’écran était le fait des actions du programme lui-même. Dans un environnement Windows 95 ou Windows NT, de nombreuses applications peuvent s’exécuter simultanément sur un écran.

Que se passe-t-il si une fenêtre est recouverte par une autre ou si elle est redimensionnée ?

Le système peut garder une copie de l’écran en mémoire et effectuer en mémoire les modifications qui ne sont pas visibles. Cette méthode serait très coûteuse en ressources, tout particulièrement si de nombreuses applications s’exécutent. Au lieu de cela, le système d’exploitation prévient l’application que quelque chose a changé et c’est à l’application d’y remédier. Dès qu’une mise à jour est nécessaire, un événement OnPaint survient.

Delphi ne redessine que la partie du canevas qui a été affectée ou invalidée. Lorsqu’une partie d’une fiche est invalide, Delphi appelle la procédure spécifiée dans le Gestionnaire d’événements OnPaint, afin de redessiner la partie invalidée de la fiche.

L’exemple suivant place dans le Gestionnaire d’événements OnPaint un code qui dessine un quart de cercle dans la fiche. Il fait également apparaître une boîte d’édition affichant le nombre de fois où la fiche a été repeinte.

unit unitOnPaint; interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls,Forms, Dialogs,StdCtrls;

type

TForm1 = class(TForm) NumRepaints: TEdit; procedure FormPaint(Sender: TObject); procedure FormCreate(Sender: TObject);

private

{ déclarations privées }

NumPaints : integer; public

{ déclarations publiques } end;

var

Form1: TForm1;

implementation {$R *.DFM}

NumPaints := NumPaints + 1;

(100,100,200,200,100,100,100,200);

:= IntToStr(NumPaints); end;

procedure TForm1.FormCreate(Sender: TObject); begin

NumPaints := 0; end; end.

Lorsque vous exécutez ce programme, vous pouvez voir le compteur d’itération augmenter chaque fois que le gestionnaire OnPaint est appelé. Cela est dû au fait que la variable NumPaints est incrémentée et affichée à chaque appel au gestionnaire OnPaint.

COMPOSANT TPAINTBOX

Tous les dessins que vous avez effectués jusqu’ici l’ont été sur le canevas ou sur une fiche. Il est souvent utile de confiner un graphique à une région rectangulaire d’une fiche. Delphi propose un composant le permettant : TPaintBox.

Exemple :

PaintBox1.canvas.Ellipse(0,0,2*PaintBox1.Width,2*PaintBox1.Height);

Que se passe t-il ? Vous avez demandé une ellipse mais Delphi n’a tracé qu’un arc. En effet, l’ellipse est plus grande que le composant TPaintBox, qui est la seule zone dans laquelle Delphi peut dessiner. Le reste de l’ellipse a été tronqué. Imaginez la complexité d’une application qui s’assurerait que rien n’est dessiné en dehors d’une région donnée. Le composant TpaintBox s’en charge pour vous. Les coordonnées dans une TPaintBox sont relatives à la TPaintBox elle-même, pas à la fiche. Cela signifie également que tant que le Gestionnaire d’événements OnPaint est responsable du tracé de la TPaintBox, vous pouvez déplacer l’image sur la fiche en modifiant les propriétés Top et Left de la TPaintBox. La TPaintBox utilise la propriété Align afin que l’image reste au sommet, sur la gauche, sur la droite ou au bas de la fiche. Cette propriété oblige également la TPaintBox à remplir la zone client de la fiche.

PRODUIRE DES IMAGES

Les méthodes et les composants graphiques conviennent parfaitement à la plupart des applications, mais il arrive qu’un développeur souhaite ajouter une image graphique prédessinée à son application. Cela serait assez dur à réaliser si l’on ne disposait que de composants graphiques.

Prenons un exemple : les entreprises Bartlebooth, fabricants de puzzles, veulent placer la photo de leur fondateur sur tous les documents de l’entreprise. Obtenir ce résultat avec les méthodes graphiques serait un vrai cauchemar. Il vous suffit de prendre une photo de John Barnabooth et de la numériser en utilisant un scanner. Le programme de numérisation stocke l’image dans un format particulier que Delphi peut comprendre et se contente d’afficher. Les méthodes ne conviennent pas non plus si un artiste conçoit une image dans un programme de dessin et souhaite l’incorporer dans une application Delphi.

Windows 3.1, Windows NT et Windows 95 ont édicté des formats de fichiers standard pour les bitmap. Les bitmap Windows sont des bitmap indépendants du matériel, ce qui signifie que les informations sont stockées de telle façon que n’importe quel ordinateur peut afficher l’image dans la résolution et avec le nombre de couleurs de sa définition. Cependant, cela ne veut pas dire que l’image a le même aspect sur n’importe quel ordinateur. Le résultat sera bien meilleur sur un écran acceptant une résolution de 1024 par 768 en couleurs 24 bits que sur un moniteur VGA standard. Le point à retenir est que les utilisateurs de ces deux ordinateurs pourront voir l’image. Ce standard permet au développeur de ne pas se soucier de la signification de chaque octet de ses fichiers bitmap.

Fort heureusement, les détails du format de fichier bitmap sont encapsulés dans le système d’exploitation et dans Delphi. Le moyen le plus facile d’afficher un bitmap en Delphi consiste à utiliser le composant TImage. Ce composant peut afficher différents types d’images graphiques. Il peut charger un bitmap provenant d’un fichier, et lui servir de conteneur dans l’application. Vous pouvez ainsi distribuer l’application sans devoir inclure un fichier bitmap distinct dans le logiciel.

Les icônes sont en fait de très petits bitmaps. Elles appartiennent à une autre catégorie car elles servent généralement à figurer un raccourci vers une application ou une vue réduite d’objet. De manière interne, les icônes sont stockées comme les bitmap. Les métafichiers et les métafi-chiers avancés, en revanche, sont stockés de façon totalement différente. Un métafichier ne stocke pas des séries de bits décrivant l’image, mais des informations indiquant la façon dont l’image a été créée.

ETIRER ET REDIMENSIONNER DES IMAGES

Par défaut, une image est affichée dans sa résolution d’origine, et vous n’en voyez que la partie qui est affichée dans le composant TImage. Deux propriétés importantes affectent la façon dont une image apparaît dans un TImage. La propriété Autosize fait que la taille du composant correspond aux dimensions de l’image. En définissant comme True la propriété Stretch (étirement) du composant, vous obligez l’image à prendre les dimensions du composant. Si vous définissez comme False les propriétés Stretch et Autosize, l’image est par défaut centrée dans le composant. Pour obliger l’image à s’afficher dans le coin supérieur gauche du composant, définissez comme False la propriété Center.

Vous avez vu comment utiliser le composant TImage pour afficher un bitmap, un métafichier ou une icône en déclarant l’image au moment de la conception de votre application. Vous pouvez également charger un bitmap provenant d’un fichier en cours d’exécution à l’aide de la méthode LoadFromFile. La ligne qui suit charge le bitmap d’installation de Windows 95 dans votre composant d’image :

Image1.Picture.LoadFromFile(’C:\WIN95\’);

Remarquez que la méthode opère sur la propriété Picture du composant d’image et non sur le composant lui-même. L’image utilise la plupart de ses propriétés pour décrire la façon dont elle interagit avec l’application. La propriété Picture contient des informations sur l’image elle-même, vous devez donc charger l’image dans cette propriété.

CRÉER SON PROPRE BITMAP

Nous vous avons montré précédemment comment dessiner sur le canevas d’une fiche et d’une

CRÉER ENTIÈREMENT UN BITMAP

Pour créer un nouveau bitmap, vous devez déclarer une variable de type TBitmap et utiliser la méthode Create comme constructeur pour allouer de l’espace au bitmap.

Var

MyBitmap : TBitmap;

BEGIN MyBitmap := TBitmap.Create;

Pour l’instant, le bitmap a été créé mais il est encore vide. Il convient maintenant de définir ses dimensions. Utilisez pour cela les propriétés Height et Width :

MyBitmap.Height := 100; MyBitmap.Width := 200;

Avant de dessiner le bitmap, ajoutez-lui quelques graphiques (ici, une ligne diagonale).

MyBitmap.Canvas.MoveTo(200,100);

MyBitmap.Canvas.LineTo(0,0);

Pour afficher un bitmap, vous pouvez utiliser la méthode Draw qui en copie un sur un canevas.

Toute autre manipulation du bitmap s’effectue en mémoire. Pour dessiner le bitmap sur Form1 aux coordonnées 100,100, utilisez la ligne suivante :

(100,100,MyBitmap);

Lorsque vous avez terminé avec le bitmap, vous devez libérer ses ressources système à l’aide de la méthode Free :

;

Une méthode pour afficher le bitmap consiste à définir celui que vous avez créé comme l’image d’un composant d’image :

Image1.Picture.Graphic := MyBitmap;

L’un des avantages de cette méthode est que vous n’avez plus à vous soucier d’une éventuelle invalidation de l’image car le composant se charge de son réaffichage.

Plusieurs méthode permet de dessiner tout ou partie d’un dessin.

La méthode Draw dessine sur le canevas le graphique spécifié par le paramètre Graphic au point de coordonnées écran (X, Y) exprimées en pixels. Le graphique peut être un bitmap, une icône ou un métafichier.

Exemple

Lorsque l'utilisateur clique sur Button1, le code suivant dessine le graphique C:\WINDOWS\ en le centrant dans Form1. Rattachez ce code au gestionnaire d'événement OnClick de Button1.

                            Bitmap1: TBitmap;

begin

                            Bitmap1 := TBitmap.Create;

                            Bitmap1.LoadFromFile('c:\windows\');

((Form1.Width div 2)-(Bitmap1.Width div 2),

(Form1.Height div 2) - (Bitmap1.Height div 2), Bitmap1); end;

La méthode StretchDraw dessine le graphique spécifié par le paramètre Graphic dans le rectangle spécifié par le paramètre Rect. Cette méthode permet d'adapter un graphique à la taille du rectangle.

Exemple Le code suivant adapte le bitmap pour remplir la zone client de Form1 :

Form1.Canvas.StretchDraw(Form1.ClientRect, TheGraphic);

procedure BrushCopy(const Dest: TRect; Bitmap: TBitmap; const Source: TRect; Color:

TColor);

La méthode BrushCopy copie une partie de bitmap dans une partie de canevas, en remplaçant l'une des couleurs du bitmap avec le pinceau du canevas de destination. Dest spécifie la partie rectangulaire du canevas de destination où s'effectue la copie. Bitmap indique le graphique source de la copie. Source spécifie la zone rectangulaire du bitmap à copier. Color indique la couleur du Bitmap qui doit être modifiée par le pinceau du canevas (spécifié par la propriété Brush).

BrushCopy peut servir à rendre une image copiée partiellement transparente. Pour ce faire, il suffit de spécifier la couleur de la surface de destination (clBackground par exemple) comme couleur de la propriété Brush du canevas avant d'appeler BrushCopy.

Exemple

Le code suivant montre les différences entre CopyRect et BrushCopy. Le graphique bitmap '' est chargé dans Bitmap puis affiché sur le canevas de Form1. BrushCopy remplace la couleur noire du graphique au moyen du pinceau du canevas, contrairement à CopyRect qui ne modifie pas ses couleurs.

var

begin

                            := 10;

                            := 10;

                            MyRect.Bottom := 100;

                            MyRect.Right := 100;

                            := 111; {110}

                            := 10;

                            MyOther.Bottom := 201; {210}

                            MyOther.Right := 100;

                            Bitmap := TBitmap.Create;

                            Bitmap.LoadFromFile('c:\windows\');

             Form1.Canvas.BrushCopy(MyRect,Bitmap, MyRect, clBlack);   Form1.Canvas.CopyRect(MyOther,Bitmap.Canvas,MyRect); end;

procedure CopyRect(Dest: TRect; Canvas: TCanvas; Source: TRect);

La méthode CopyRect copie dans l'objet canevas une partie d'image d'un autre canevas. La propriété Dest spécifie le rectangle cible du canevas cible. La propriété Canvas spécifie le canevas source. La propriété Source spécifie le rectangle source du canevas source.

Exemple L'exemple de code suivant copie le bitmap source inversé sur le canevas de Form2 :

Form2.Canvas.CopyMode := cmNotSrcCopy;

Form2.Canvas.CopyRect(ClientRect, Canvas, ClientRect);

ENREGISTRER UN BITMAP DANS UN FICHIER

Vous pouvez non seulement charger ou manipuler des bitmap, mais aussi les enregistrer dans un fichier. Pour sauvegarder le bitmap, utilisez simplement la méthode SaveToFile.

My bitmap.SaveToFile (’C:\Perso\MyBitmap. BMP’) ;

COULEURS ET TRACÉS

Les couleurs SYSTEME

Les couleurs de base

LES MODES DE TRACE

La table suivante résume les 16 modes de tracé. Cette table indique comment sont combinées les couleurs du stylo (S) et de la destination (D) pour donner la couleur finale de la destination. La colonne "opération booléenne" utilise la notation 'C' pour exprimer l'opération logique effectuée par Windows.

Le mode notCopy trace en noir si le stylo est blanc est en blanc s'il est noir.

Le mode pmNop n'effectue aucune modification de la destination.

Tableau explicitant l'effet de la propriété mode.

REMPLIR DES FORMES

Windows prévoit deux fonctions permettant de remplir avec une couleur soit un rectangle, soit une zone quelconque pourvue qu'elle soit fermée. La couleur du remplissage est la couleur du pinceau en cours.

procedure FillRect(const Rect: TRect);

La méthode FillRect remplit le rectangle spécifié du canevas en utilisant le pinceau du canevas.

Exemple

Le code suivant crée un rectangle dans le canevas de la fiche et le colorie en rouge en définissant la propriété Brush du canevas à clRed :

procedure TForm1.ColorRectangleClick(Sender: TObject); var

                            NewRect: TRect;

begin

                            NewRect := Rect(20, 30, 50, 90);

             Form1.Canvas.Brush.Color := clRed;   Form1.Canvas.FillRect(NewRect); end;

procedure FloodFill(X, Y: Integer; Color: TColor; FillStyle: TFillStyle);

La méthode FloodFill remplit une zone de la surface de l'écran en utilisant le pinceau en cours (spécifié par la propriété Brush). La méthode FloodFill commence au point de coordonnées (X, Y) et continue dans toutes les directions jusqu'aux limites de couleur.

La manière de remplir la zone est déterminée par le paramètre FillStyle. Si FillStyle est à fsBorder, la surface est remplie jusqu'à ce qu'une bordure de la couleur spécifiée par le paramètre Color soit rencontrée. Si FillStyle est à fsSurface, la surface est remplie tant que la couleur spécifiée par le paramètre Color est rencontrée. Les remplissages fsSurface sont utiles pour remplir une zone ayant une bordure multicolore.

Exemple

Le code suivant remplit de couleur, depuis le centre de la zone client de Form1 jusqu'à ce que la couleur noire soit rencontrée :

MODES DE TRACÉ GRAPHIQUE

Lorsqu'on dessine dans un contexte graphique, les nouveaux tracés écrasent par défaut les traces existantes. On dit qu'on est dans un mode cmScrCopy, c'est à dire que le tracé sera celui de la couleur du crayon. Mais vous pouvez combiner la couleur du pinceau avec les dessins existants. On parle alors d'opérations logiques entre les pixels du pinceau avec les dessins existants. voici les différents modes de tracé :

La propriété CopyMode détermine le traitement d'une image copiée sur le canevas à partir d'un autre canevas. La valeur par défaut cmSrcCopy de CopyMode signifie que les pixels du canevas source sont copiés sur le canevas cible en remplaçant l'image qui s'y trouve. En changeant CopyMode, il est possible de créer des effets spéciaux. Le tableau suivant donne la liste des valeurs possibles de CopyMode, avec leur description:

Exemple

Form2.Canvas.CopyMode := cmNotSrcCopy;

Form2.Canvas.CopyRect(ClientRect, Canvas, ClientRect);

CODAGE DE LA COULEUR :

Sous Windows, toute couleur est obtenue en mélangeant les trois couleurs de base, dites couleurs primaires.

Le système RGB (Red-Green-Blue) utilisé en vidéo définit une couleur quelconque comme un ensemble de valeurs de 0 à 255 correspondant à une intensité respective des 3 couleurs primaires. Il permet de distinguer 255³ couleurs, soit environ 16 millions de couleurs.

Dans Windows, une valeur RGB est représentée sous la forme d'un entier long (4 octets). Les intensités du rouge, du vert et du bleu sont stockées chacune sur un octet, le quatrième octet n'étant pas utilisé. DELPHI utilise lui un type particulier, le type TColor, pour coder les couleurs.

Il faut donc utiliser des fonctions permettant de convertir les valeurs RGB en valeurs TColor et réciproquement.

ColorToRGB convertit un type TColor en valeur RGB

RGB                calcule une valeur RGB à partir des  intensités des couleurs primaires

GetBValue     retourne l'intensité du bleu à partir d'une valeur RGB

GetGValue     retourne l'intensité du vert à partir d'une valeur RGB

GetRValue     retourne l'intensité du rouge à partir d'une valeur RGB

Il n'y a pas de fonction permettant de convertir directement une valeur RGB en TColor.

Pour qu'une boite de liste contienne des images il faut tout :

1.      Initialiser la propriété style à la valeur lbOwnerDrawFixed ou lbOwnerDrawVariable. Dans le premier cas, la hauteur de chaque item est identique, déterminée par la propriété ItemHeight. Dans le deuxième cas, elle doit être indiquée pour chaque item dans l'événement OnMeasureItem.

2.      Créer un gestionnaire d'événement avec l'événement OnDrawItem. On peut alors dessiner ce que l'on veut sur le canevas. Il faut néanmoins respecter le cadre du rectangle affecté à l'item. Ce rectangle est passé en argument à la procédure événementielle.

Les données nécessaires au dessin sont généralement stockées directement dans les items.

Rappelons que la propriété items est un objet de type Tstrings : il est alors possible d'associer à chaque chaîne un objet, par exemple de type bitmap. Pour un indice i donné, la chaîne est items.strings[i] et l'objet items.objects[i].

 Uniquement à l'exécution   .

La propriété Objects permet, uniquement à l'exécution, d'accéder à un objet de la liste d'objets associée à la liste de chaînes. Chaque chaîne d'une liste de chaînes a un objet associé.

Le plus souvent, les objets d'une liste de chaînes et d'objets permettent d'associer des bitmaps aux chaînes afin d'utiliser les bitmaps dans des contrôles dessinés par le propriétaire.

Par exemple, dans une boîte liste dessinée par le propriétaire, il est possible d'ajouter la chaîne 'Banane' et une image bitmap de la banane à la propriété Items de la boîte liste en utilisant la méthode AddObject. Il est alors possible d'accéder à la chaîne 'Banane' en utilisant la propriété Strings et au bitmap en utilisant la propriété Objects.

Pour associer un objet à une chaîne existante, il faut affecter l'objet à la propriété Objects en utilisant le même indice que celui de la chaîne existante dans la propriété Strings. Si, par exemple, un objet chaîne nommé Fruits contient la chaîne 'Banane' et s'il existe une image bitmap d'une banane nommée BananaBitmap, il est possible de faire l'affectation suivante :

Fruits.Objects[Fruits.IndexOf('Banane')] := BananaBitmap;

Exemple

Le code suivant permet à l'utilisateur de spécifier un fichier bitmap avec le composant boîte de dialogue d'ouverture OpenDialog1 lors de la création de Form1. Le fichier bitmap spécifié est ajouté à la liste Items de ListBox1. Si ListBox1 est un contrôle dessiné par le propriétaire (un contrôle dont la propriété Style est lbOwnerDrawFixed ou lbOwnerDrawVariable ), la deuxième procédure est le gestionnaire d'événement OnDrawItem de ListBox1. Le bitmap de la propriété Object et le texte d'un élément sont obtenus et affichés dans Listbox1

procedure TForm1.FormCreate(Sender: TObject); var

TheBitmap: TBitmap; begin if OpenDialog1.Execute then begin

TheBitmap := TBitmap.Create;

TheBitmap.LoadFromFile(OpenDialog1.FileName);

ListBox1.Items.AddObject(OpenDialog1.FileName, TheBitmap); end;

end;

procedure TForm1.ListBox1DrawItem(Control: TWinControl; Index: Integer; Rect: TRect; State: TOwnerDrawState); var

                            DrawBitmap: TBitmap;

begin

DrawBitmap := TBitmap(ListBox1.Items.Objects[Index]); with ListBox1.Canvas do

begin

                                        Draw(, + 4, DrawBitmap);

                                        TextOut( + 2 + DrawBitmap.Width, + 2,

ListBox1.Items[Index]);

                            end;

end;

L'utilisation des DLL apporte les avantages suivants :

Ø        La DLL n'est chargée que lorsque l'on a besoin des fonctions qu'elle contient. Mais cet avantage n'en est un que dans le cas où l'on n'utiliserait pas les possibilités de chargement dynamique des fenêtres de DELPHI et que les DLL constituées ne soient pas trop importantes.

Ø        Comme le concept des Unités, dans le monde du Pascal, on peut partager le code d'une DLL entre plusieurs applications. Il s'agit là de l'avantage prépondérant : si une DLL est constituée de fonctions utilisées par plusieurs applications il n'y a qu'un chargement en mémoire. D'où une économie certaine. Cet avantage n'en est un que si l'on ne crée pas des DLL spécifiques à chaque application.

Ø        Le format d'une DLL est standardisé : on peut donc appeler des DLL créées dans un autre langage. On peut de même placer dans une DLL des fonctions qui ne sont pas fournies par un environnement de développement donné. Lors de la programmation d'une application l'appel de la DLL suppléera à ces manques.

 Il faut bien entendu que les paramètres demandés par les fonctions de la DLL et, le cas échéant, les résultats renvoyés aient des types compatibles avec ceux des autres langages.

Par exemple, si l'on souhaite utiliser une DLL écrite avec DELPHI dans un environnement utilisant le langage C, on peut utiliser des variables de types Char, Integer, etc mais pas Boolean.

 Il existe différents types de DLL (mais elles sont souvent un mélange des trois):

•  DLL de fonctions : c'est le cas général de bibliothèques partagées.

•  DLL de données partagées : plusieurs applications peuvent se partager ces données.

•  DLL de ressources : ces DLL ne contiennent que des ressources graphiques (bitmaps, icônes, curseurs, etc ).

Elle gère alors un compteur qui s'incrémente à chaque fois qu'elle est recherchée par une application. Ce compteur se décrémente lorsqu'une application cesse de l'utiliser.

Lorsque le compteur revient à zéro, la DLL est déchargée de la mémoire.

Mode d'appel d'une DLL :

Le mode d'appel des fonctions d'une DLL est celui standardisé par Windows, c'est à dire celui du Pascal (les paramètres sont placés dans la pile mais c'est l'application appelante qui vide la pile au retour de la fonction ) et non celui du langage C (c'est la fonction appelée qui vide la pile ).

Ce qui fait qu'il n'est pas nécessaire de modifier les prototypes des fonctions d'une DLL (alors que les DLL construites en C doivent utiliser le mot clé 'Pascal' pour qu'elles soient appelées selon le mode Pascal ).

Pour créer une DLL il faut reprendre en grande partie la procédure de création d'un projet. On peut donc créer une DLL à partir de et proposé au démarrage par DELPHI.

Bien évidemment un "projet" DLL peut contenir plusieurs unités. Il peut n'être constitué que de fichiers '.PAS' (dans ce cas il vaut mieux ouvrir le menu 'Fichier | Nouvelle unité ' ) ou contenir des interfaces (dans ce cas, il faut appeler 'Fichier | Nouveau Projet ' ).

Modification du fichier :

L'essentiel des modifications à apporter au projet pour qu'il soit compiler en tant que DLL se situe dans le fichier source du projet ( d'extension .DPR )

-      Changer le mot réservé 'Program' par 'Library'.

-      Supprimer le mot 'Forms' et les lignes qui en dépendent de la clause 'Uses'.

-      Ajouter la clause 'Exports' après la clause 'Uses'.

-      Supprimer tout ce qui se trouve dans le bloc d'initialisation ( , etc ).

La section 'Exports' contiendra le nom de toutes les routines exportées, c'est à dire celles qui peuvent être appelées à partir d'une application.

La DLL prendra le nom de la librairie. Comme d'habitude il faut laisser à DELPHI le soin de modifier lui-même ce nom en sauvegardant le projet.

Voilà le squelette d'une DLL :

library Madll; uses

                             Dll1 in '' {FDLL};

{$R *.RES} begin end.

{ La clause Exports sera rajoutée ultérieurement }

Modification dans les unités :

Dans les unités contenant les diverses fonctions de la DLL les modifications sont réduites à l'ajout du mot réservé à la fin de l'en-tête décrivant les fonctions exportées dans la section 'interface' :

Dans l'exemple précédent on a alors :

type

             TFDLL = class(TForm)        private

                            { Private-déclarations }

                            public

                            { Public-déclarations }

                            end;

Function Puissance ( valeur , exposant : longint ) : longint ; Export ;stdcall ;

La déclaration de la fonction, dans la section 'implementation', reste inchangée :

Function Puissance (valeur, exposant : longint ) : longint ;stdcall ; var    i : longint ;          transit : longint ; begin

                             case exposant of

             0 : result := 1 ;           1 : result := valeur ;

                                        else

begin

                                        i := 2 ;

transit := valeur ; while ( i <= exposant ) do

begin

                                                               transit := transit * valeur ;

                                                    end ;

                                                       result := transit ;

end ;

end;

end ;

Il faut alors revenir dans le source du projet (.DPR) pour rajouter la clause 'Exports', sous la clause 'Uses', et y indiquer le nom de la fonction exportée.

exports

                        Puissance ;

Il faut enfin compiler le projet pour créer la DLL. Pour cela il faut passer par le menu 'Compiler | Tout construire ' ( le menu 'Exécuter' ne servant à rien dans ce cas ).

La DLL, au nom du projet et à l'extension .DLL est créée.

MISE EN PLACE ET CHARGEMENT D'UNE DLL :

Mise en place :

Normalement une DLL est placée dans le répertoire où se trouve l'exécutable de l'application qui l'utilise. Elle est alors directement accessible.

Si l'on souhaite que la DLL soit partagée par plusieurs applications il faut positionner celle-ci dans un répertoire où Windows la recherchera.

Lorsqu'un programme appelle une DLL, Windows effectue la recherche dans l'ordre suivant:

-      Répertoire de l'application appelante ;

-      Répertoire Windows ;

-      Sous-répertoire System32 de Windows ; -      Chemins du PATH.

Il est donc préférable de positionner une DLL partageable dans le répertoire Windows ou son sous-répertoire System32.

Chargement d'une DLL :

Il est possible de charger une DLL selon deux modes :

Le mode statique :

Dans ce mode, le nom de la DLL à charger est indiqué explicitement dans le source de l'application appelante. Le chargement a lieu au lancement de l'application.

Le mode dynamique :

Dans ce mode, plus complexe à mettre en œuvre, les DLL ne sont chargées qu'au cours de l'exécution, si elles sont nécessaires.

Néanmoins une DLL chargée statiquement reste partageable.

CHARGEMENT STATIQUE D’UNE DLL

Une fonction définie dans une DLL doit être déclarée par l'application appelante avant d'être utilisée.

Cette déclaration doit être réalisée dans la partie 'implémentation' d'une unité avant la définition des fonctions qui la constitue. La syntaxe de cette déclaration est la suivante :

< Prototype de la fonction appelée > ; stdcall ; external < nom de la DLL >

                              La déclaration du prototype est faite selon les règles habituelles ;

 Le mot réservé 'stdcall' défini la convention d'appel, c'est à dire le protocole utilisé pour le passage des variables à une fonction. Pour assurer la compatibilité avec

Win32, il est conseillé d'utiliser 'stdcall' ;

                              Le nom de la DLL doit être écrit avec son extension.

Si l'on crée un projet contenant une feuille permettant de calculer la valeur de la puissance d'un nombre (3 zones d'édition : une pour entrer la valeur, l'autre l'exposant, la troisième affichant le résultat après le calcul ). On a la déclaration suivante :

implementation {$R *.DFM}

Function Puissance( valeur , exposant : longint ): longint ; far ; external '';

..

L'appel de la fonction appartenant à la DLL se fait alors de manière classique au sein d'un gestionnaire d'événement :

procedure TForm1.Button1Click ( Sender : TObject) ; var

                            Calcul : longint ;

begin

                        Calcul:=Puissance(StrToInt ( ) , StrToInt ( ));  := IntToStr ( Calcul ) ;

                        EValeur.Clear ;

                        EExposant.Clear ;

                        EValeur.SetFocus ;

end ;

On utilise alors la syntaxe de déclaration :

 < Prototype de la fonction > ; far ; external 'NOM_DLL' index numéro ;

Exemple :

Function Puissance(valeur,exposant:longint):longint;far;external '' index 1;

CHARGEMENT DYNAMIQUE D’UNE DLL

Pour réaliser un chargement dynamique d'une DLL, plus performant, nécessite l'utilisation de deux fonctions de l'API Windows : LoadLibrary ( ) et GetProcAddress ( ).

Function LoadLibrary ( LibFileName: PChar): THandle;

Cette fonction charge une DLL, spécifiée par un pointeur sur une chaîne de caractères AZT, en mémoire afin que les fonctions qu'elle contient puissent être invoquées.

Si le chemin spécifié n'est pas complet Windows recherche la DLL dans les répertoires indiqués précédemment.

Le compteur d'utilisation de la DLL est incrémenté. Si la DLL est déjà chargée en mémoire, il n'y a pas de nouveau chargement mais simplement incrémentation du compteur.

Function GetProcAddress (Module: THandle; ProcName: PChar):TFarProc;

Cette fonction renvoie l'adresse de la DLL spécifiée par Module.

ProcName est une chaîne AZT contenant le nom de la fonction appelée ( ou alors indique son numéro d'index ).

Renvoie NIL si échec.

Procedure FreeLibrary ( LibModule : THandle) ;

Cette fonction décrémente le compteur de chargement de la DLL spécifiée par le handle LibModule.

Quand le compteur est à zéro, la DLL est déchargée de la mémoire ( la zone mémoire occupée est rendue libre.

La procédure à respecter, pour appeler dynamiquement une DLL est la suivante :

1-     Déclarer un type particulier correspondant au prototype de la fonction à appeler puis une variable à ce type. ( en fait, il s'agit de déclarer un pointeur sur une fonction d'un type donné ).

Dans l'exemple précédent on déclare ainsi le type suivant :

type

             TFonctionDLL= Function ( val , exp : longint ) :longint ; var

2-     Charger la DLL dans le gestionnaire d'événement approprié et y rechercher la fonction souhaitée :

procedure TForm1.Button1Click ( Sender : TObject) ; type

             TFonctionDLL= Function ( val , exp : longint ) : longint ; var

                            UneFonctionDLL : TFonctionDLL ;

             Calcul : longint ;        HandleDLL : THandle ;

begin

                        HandleDLL := LoadLibrary ( ' ' ) ;

@UneFonctionDLL := GetProcAddress ( HandleDLL, 'Puissance' ) ; if @UneFonctionDLL <> Nil then

 Calcul := UneFonctionDLL ( StrToInt ( ),

StrToInt ( )) ;

                        FreeLibrary ( HandleDLL ) ;

:= IntToStr ( Calcul ) ;

EValeur.Clear ;

EExposant.Clear ;

EValeur.SetFocus ; end ;

{ L'opérateur '@' utilisé dans l'expression '@UneFonctionDLL' permet de ne pas typer la variable (c'est à dire se conformer à ce qui est renvoyé par GetProcAddress ()}

DLL GRAPHIQUE

CRÉATION D’UNE NOUVELLE DLL

Exemple :création d'une DLL graphique de saisie de date valide

Fichier library Date;

uses

    {utilise l'unité unit1}

    Unit1 in '' {dateinfo};

Seul choix_date est utilisable

                exports                                                                  à partir d’une application

       choix_date;

{$R *.RES}

begin end.

Fichier unit Unit1; interface

uses

  SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls,

  Forms, Dialogs, StdCtrls, Buttons, Grids, Calendar;

type

  Tdateinfo = class(TForm)     mois: TComboBox;     annee: TComboBox;     calendrier: TCalendar;     BitBtn1: TBitBtn;     BitBtn2: TBitBtn;

    {méthode appelée lors de l'exécution de la DLL}

    function getdate :string;   public   end;

const

     {pour plus de détail voir function FormatDateTime(): string;}

     slongmonthnames = 65488;      sshortmonthnames = 65472;      sshortdaynames = 65504;      slongdaynames = 65511;

var   dateinfo: Tdateinfo;

  {la procédure getdate est exportable}

  {===========================================================

}

  procedure choix_date(handle : thandle; var s: string);export;

  {===========================================================

}

implementation {$R *.DFM}

{création de la fenetre graphique}

procedure Tdateinfo.FormCreate(Sender: TObject); var

   i : integer; begin

     {chargement des combobox}      for i:=0 to 11 do  (loadstr(slongmonthnames+i));      for i:=1990 to 2010 do (inttostr(i));

     mois.itemindex:=calendrier.month -1;

     annee.itemindex:=annee.items.indexof(inttostr()); end;

{changement du mois}

procedure Tdateinfo.moisChange(Sender: TObject); begin

     calendrier.month:=mois.itemindex +1; end;

{changement de l'année}

procedure Tdateinfo.anneeChange(Sender: TObject); begin

     :=strtoint(); end;

{getdate est une méthode de dateinfo qui renvoie la date choisie} function Tdateinfo.getdate : string;

begin

     result := inttostr()+'/'+inttostr(calendrier.month)+'/'+             inttostr(); end;

{ primitive de la DLL}

{utilise la handle de l'application et met la date dans un chaine de caractères} procedure choix_date(handle : thandle; var s: string); begin

     {récupération du handle}

     {La propriété Handle donne accès au descript. de fenêtre de l'application}      application.handle:=handle;

     {création de la forme}      dateinfo:=tdateinfo.create(application);

        s:=dateinfo.getdate

     else          s:='inconnu';

     {libération des ressources}      ; end; end.

APPEL DE LA DLL

Cette application fait appel à la DLL graphique pour saisir une date valide

{utilisation d'une DLL graphique} unit Unite; interface

uses

                            SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls,

                            Forms, Dialogs, StdCtrls, Buttons;

type

                            TForm1 = class(TForm)

             BitBtn1: TBitBtn;     Edit1: TEdit;

                                        procedure BitBtn1Click(Sender: TObject);

                            private

                            { Déclarations private }

                            public

                            { Déclarations public }

                            end;

var

                            Form1: TForm1;

implementation {$R *.DFM}

{chargement statique d'une DLL} procedure choix_date( handle : thandle; var s : string);stdcall;external 'date';

{appel de la primitive de la dll}

                procedure TForm1.BitBtn1Click(Sender: TObject);    ^{On passe le handle de}

var       l’application en paramètre et on         chaine :string;            récupère la réponse dans chaine. begin

             choix_date(application.handle,chaine);      :=chaine; end; end.

Page 106 sur 370

Vous pouvez ainsi développer des composants visuels Delphi natifs et ActiveX. Les premiers peuvent être construits et installés dans l’EDI Delphi, sans les complications associées aux ActiveX. Les seconds peuvent être importés dans Delphi, Visual Basic, dans des pages Web, et dans tout autre produit capable de les incorporer.

Nous commencerons par un aperçu des avantages liés à l’utilisation de composants, puis nous verrons comment créer des composants visuels en Delphi, en commençant par un exemple très simple pour finir sur des composants utiles et puissants. Nous verrons ensuite la manière dont Delphi peut convertir des composants visuels en ActiveX.

POURQUOI ÉCRIRE DES COMPOSANTS ?

La puissance des composants tient au fait qu’ils cachent au développeur tous les détails de l’implémentation. De même qu’un conducteur n’a pas besoin, pour conduire, de connaître les principes thermodynamiques à l’œuvre dans un moteur à explosion, un développeur d’application n’a pas besoin de savoir comment fonctionne un composant pour l’utiliser. Il lui suffit de savoir comment communiquer avec lui. Il y a au moins quatre bonnes raisons d’écrire vos propres composants.

RÉUTILISER LE CODE

L’interface vers un composant est intégrée à l’environnement de développement Delphi. Par conséquent, si vous utilisez fréquemment un objet, vous pouvez le transformer en composant visuel, l’ajouter à la barre d’outils, ce qui en facilite l’utilisation et en cache l’implémentation au sein de la bibliothèque.

Comme Delphi est un langage orienté objet et comme un composant visuel est un objet, vous pouvez créer un composant visuel comme sous-classe d’un composant déjà existant. Supposons, par exemple, que vous utilisiez souvent des cercles bleus dans vos applications.

VENDRE DES COMPOSANTS

Si vous devez ajouter des fonctionnalités spécialisées à votre application, vous pouvez acheter un composant à un éditeur indépendant. C’est l’un des plus grands avantages d’un système basé sur les composants. Ainsi, si vous avez besoin de fonctions de réseau, vous pouvez écrire vous-même les routines afférentes ou acheter un ensemble de composants qui se chargent de ces fonctionnalités. De même, vous pouvez créer un composant et le vendre à d’autres développeurs.

Lorsque vous vendez la bibliothèque, vous ne fournissez qu’une version compilée du produit. Votre client ne voit donc pas son code source ou les détails de son implémentation. Cependant, lorsque le composant est ajouté à une fiche, votre acheteur peut communiquer avec le composant par le biais de l’IDE.

MODIFICATIONS DE COMPORTEMENT

Si vous compilez du code pour en faire un composant visuel, vous pouvez voir son aspect se modifier au cours du développement. Ainsi, si vous définissez comme un cercle la propriété Shape du composant TShape, la forme sur la fiche se transforme en cercle, et ce, avant que le composant ne soit compilé. Cela est très utile dans le cas de composants qui sont visibles dans l’application. Vous pouvez ainsi savoir à quoi celle-ci ressemblera une fois compilée.

CONSTRUIRE ET INSTALLER UN COMPOSANT

Il est facile de créer des DLL, mais elles ne s’intègrent pas à l’EDI de Delphi. Elles sont utiles, mais ne sont pas orientées objets. Les composants visuels ne comportent pas ces deux défauts.

Le premier que vous allez construire dans cette partie se compile simplement et s’installe ou s’enlève de la barre d’outils. Vous pouvez aussi l’ajouter à une fiche, mais il ne fera strictement rien.

AJOUTER LE COMPOSANT TDONOTHING AU PAQUET

Dans cet exemple, nous allons utiliser l’Expert composant pour générer le code nécessaire à la création du squelette d’un composant. Tous les composants doivent être issus d’autres composants.

Si vous souhaitez partir de zéro, vous devez créer une sous-classe de TComponent, comme suit :

1.   Cliquez sur l’icône Ajouter dans la boîte de dialogue Gestionnaire de paquet. La boîte.Ajouter apparaît alors.

2.   Sélectionnez l’onglet Nouveau composant.

3.   Spécifiez TComponent comme type d’Ancêtre, TDoNothing comme Nom de classe et Exemples comme Page de palette. Pour le nom du fichier d’unité, choisissez un nouveau fichier .pas qui sera utilisé pour le code source, et laissez la valeur par défaut dans le Chemin de recherche.

4.   Cliquez sur OK pour enregistrer ces paramètres.

Delphi crée le noyau d’une unité qui se compile en un composant visuel. En double-cliquant sur celle-ci dans le Gestionnaire de paquet, vous faites apparaître le code source.

Squelette d’un composant visuel unit DoNothing; interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs;

type

TDoNothing = class(TComponent) private

{ Déclarations privées } protected

{ Déclarations protégées } public

{ Déclarations publiques } published

{ Déclarations publiées} end; procedure Register; implementation

procedure Register;

begin

RegisterComponents(’Samples’, [TDoNothing]); end; end.

COMPILER ET INSTALLER PAQUET ET COMPOSANTS

Pour compiler et installer le composant, suivez ces étapes :

1.      Dans le Gestionnaire de paquet, cliquez sur l’icône Compiler. L’unité sera alors compilée dans le fichier de paquet DPK.

2.      Dans le Gestionnaire de paquet, cliquez sur l’icône Installer. Le paquet sera alors installé. Si son installation fonctionne bien, vous en serez averti par une boîte de dialogue.

Regardez la barre d’outils Exemples. Vous pouvez voir qu’un nouveau composant y est apparu. Placez le pointeur de la souris dessus pour qu’une info-bulle apparaisse. Le nouveau composant est DoNothing. Créez une nouvelle application et ajoutez-le à la fiche. Lorsque vous cliquez dessus pour visualiser les pages de propriétés et d’événements, vous voyez qu’il n’y a que deux propriétés. La propriété Name est DoNothing1 par défaut et Tag est 0 par défaut. La page d’événements n’en contient aucun. C’est un composant visuel, dont la fonction est de ne rien faire.

.

ENLEVER LE COMPOSANT

Il arrive que vous ayez besoin de retirer un composant de la barre d’outils ou de le désinstaller de Delphi. Cela peut être le cas si vous recevez une version mise à jour d’un composant visuel, ou si vous souhaitez simplement enlever un composant dont vous n’avez pas l’utilité.

TdoNothing est par essence inutile. Pour l’enlever, suivez ces étapes :

1.     Sélectionnez Projet, Options dans le menu, puis sélectionnez l’onglet Paquets.

2.     Dans cet onglet, cliquez sur le paquet que vous venez d’installer, puis cliquez sur Supprimer. Le composant TDoNothing est alors retiré de la barre d’outils.

LES DIFFERENTS TYPES DE DÉCLARATIONS

Delphi utilise des classes d’objet pour créer des composants visuels. Les différentes parties de la définition de la classe d’objet sont déclarées dans plusieurs régions protégées. Les variables, les procédures et les fonctions peuvent avoir quatre types d’accès :

Propriétés

Un développeur Delphi utilise les propriétés d’un composant pour lire ou modifier certains attributs, qui sont similaires aux champs de données stockés dans une classe. Les propriétés peuvent cependant provoquer l’exécution de code. Ainsi, lorsque vous modifiez la propriété Shape du composant TShape, ce dernier change de forme. Il existe un mécanisme qui lui ordonne de se modifier lorsque la propriété change. Autrement dit, une propriété peut endosser deux rôles. Ce peut être une donnée affectant le fonctionnement d’un composant, ou le déclencheur d’une action.

Evénements

Les événements permettent au développeur ou à l’utilisateur d’améliorer le composant lorsqu’un événement survient. Ainsi, l’événement OnClick signifie "Si vous voulez faire quelque chose lorsque l’utilisateur clique ici, dites-moi quelle procédure exécuter pour cela".

C’est le travail du concepteur d’appeler les événements du composant si nécessaire.

CONSTRUIRE UN COMPOSANT

Nous allons maintenant créer un composant visuel qui effectue une tâche et comprend au moins une propriété, une méthode et un événement. Il est assez sommaire, et son intérêt est avant tout didactique. Cela montrera aussi comment le dériver à partir du sommet de la hiérarchie des composants. Tous les composants ont TComponent dans leur arbre généalogique. TMult est un descendant direct de TComponent.

Créer TMult

Le composant TMult a deux propriétés de type integer qui peuvent être définies au moment de la conception ou de l’exécution. Il a une méthode, DoMult. Lorsque celle-ci est exécutée, les deux valeurs des propriétés sont multipliées et le résultat est placé dans une troisième propriété appelée Res. Un événement, OnTooBig est aussi implémenté. Si l’un des deux nombres est défini comme étant supérieur à 100 lorsque la méthode DoMult est appelée, le composant appelle le code vers lequel l’utilisateur à pointé dans la page d’événements. TMult est un exemple de composant purement fonctionnel : il n’a pas de composante graphique. Parmi les composants standard du même type, on peut citer TTimer, TDataBase et ceux de Table.

TMult contient les propriétés suivantes :

TMult contient une méthode, DoMult, qui implémente la multiplication de Val1 par Val2.

L’événement de TMult, OnTooBig, appelle le Gestionnaire d’événements de l’utilisateur (s’il existe) lorsque Val1 est multipliée par Val2 et qu’une des deux valeurs est supérieure à 100.

Construire TMult

La première étape consiste à créer une unité qui constituera le noyau central de tous les composants. Pour ce faire, utilisez l’Expert composant comme précédemment et nommez le fichier Tmultiply. Pour remplir les champs de l’Expert pour créer Tmult, indiquez :

Nom de classe : Tmult

Type ancêtre : Tcomponent

Page de palette : Exemples

Le code généré comprend un noyau pour la déclaration de classe de TMult et une procédure pour enregistrer la fonction. Pour développer les propriétés, la méthode et l’événement, vous devez modifier la définition de classe et fournir les procédures et fonctions correspondantes.

Double-cliquez sur l’unité TMultiply dans le Gestionnaire de paquets pour voir apparaître le code source.

type

TMult = class(TComponent)

Private

FVal1 : integer;

FVal2 : integer;

FRes : integer;

Protected

Public

Published end;

Vous devez maintenant déclarer les propriétés elles-mêmes. Utilisez le mot clé property dans la définition de classe. La définition de propriété peut apparaître généralement en deux endroits. Si une propriété est accessible lors de la conception, elle doit être déclarée dans la section Published de la déclaration. Si elle n’est disponible que lors de l’exécution, elle est placée dans la section public. Dans notre exemple, les propriétés sont stockées sous forme de types de données simples et on n’effectue pas d’action particulière lorsque les données sont lues ou écrites. On peut, par conséquent, utiliser un accès direct pour lire et écrire la propriété. Avec l’accès direct, vous indiquez à Delphi de modifier ou de renvoyer les données d’une variable lorsqu’une propriété est écrite ou lue. Les méthodes read et write définissent les variables.

Voici les définitions de nos trois propriétés :

type

TMult = class(TComponent)

Private

FVal1 : integer;

FVal2 : integer;

FRes : integer; protected public

Property Res:integer read FRes; {Propriété pour obtenir le résultat}

published property Val1:integer read FVal1 Write FVal1 default 1; property Val2:integer read FVal2 Write FVal2 default 1 ;

end; {TMult}

Comme la propriété Res est en lecture seule, vous n’avez pas besoin d’une méthode à accès direct pour écrire dans la variable FRes.

Vous avez déclaré les propriétés du composant. Si vous installez le composant maintenant, Val1 et Val2 apparaîtront dans l’onglet Propriétés. Il vous reste quelques étapes avant d’obtenir un composant fonctionnel.

Ajouter le constructeur

Un constructeur est appelé lorsqu’une classe est créée. C’est lui qui est souvent chargé de l’allocation de mémoire dynamique ou de la collecte des ressources dont a besoin une classe. Il définit aussi les valeurs par défaut des variables d’une classe. Lorsqu’un composant est ajouté à une fiche, lors de la conception ou de l’exécution, le constructeur est appelé. Pour déclarer ce dernier dans la définition de classe, ajoutez une ligne constructor dans la partie public de la déclaration de classe. Par convention, on utilise Create comme nom de la procédure du constructeur, comme on peut le voir dans cet exemple :

{…}

public constructor Create(AOwner : TComponent); override; {…}

On passe un paramètre au constructeur : le composant auquel appartient le constructeur. Ce n’est pas le même cas de figure que pour la propriété ancêtre. Vous devez spécifier que vous souhaitez ignorer le constructeur par défaut de la classe de l’ancêtre, qui est TComponent. Dans la portion implémentation de l’unité, vous ajoutez le code pour le constructeur.

constructor TMult.Create(AOwner: TComponent);

BEGIN

inherited Create(AOwner); {appel du constructeur pour la classe du parent}

FVal1 := 1; {Défaut pour valeur 1 }

FVal2 := 1; {Défaut pour valeur 2 }

END; {End constructor}

Pour qu’une construction spécifique à un parent soit effectuée, vous devez commencer par appeler la procédure Create héritée. En l’occurrence, la seule étape supplémentaire consiste à définir des valeurs par défaut pour Val1 et Val2 qui correspondent à la section des valeurs par défaut des déclarations de propriétés.

{…}

public procedure DoMult; {Méthode pour multiplier}

{…}

procedure TMult.DoMult;

Begin

FRes := FVal1 * FVal2

End;

Votre composant fonctionne maintenant. L’utilisateur peut l’ajouter à une fiche et définir des valeurs pour Val1 et Val2 lors de la conception et de cette dernière étape. Lors de l’exécution, la méthode DoMult peut être appelée pour effectuer la multiplication.

AJOUTER UN ÉVÉNEMENT

Un événement permet à l’utilisateur d’exécuter un code spécialisé lorsque que quelque chose arrive. Pour votre composant, vous pouvez ajouter un événement qui est déclenché lorsque Val1 ou Val2 est plus grand que 100 et que DoMult est exécuté ou, par exemple, modifier le code pour que, dans une telle éventualité, Res reste inchangé.

En Delphi, un événement est une propriété spécialisée, c’est-à-dire un pointeur vers une fonction. Tout ce qui s’applique aux propriétés s’applique dans ce cas aux fonctions.

Le composant doit fournir une dernière information : le moment où il faut appeler le Gestionnaire d’événements de l’utilisateur. Rien de plus simple. Dès qu’il est temps de déclencher un événement, il suffit de voir si l’utilisateur a défini un Gestionnaire d’événements. Si c’est le cas, on appelle l’événement. Vous devez ajouter les déclarations suivantes à la définition de classe :

{…}

Private

FTooBig : TNotifyEvent;

{…}

published

Property OnTooBig:TNotifyEvent read FTooBig write FTooBig;

{…}

end; {TMult}

{…}

Le Listing suivant montre le code du composant.

Le composant TMult au complet unit TMultiply; interface

uses

SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls, Forms,

Dialogs, StdCtrls;

type

TMult = class(TComponent)

Private

FTooBig : TNotifyEvent;

FVal1 : integer;

FVal2 : integer;

FRes : integer; protected public

{constructeur principal }

constructor Create(AOwner : TComponent); override;

{méthode pour multiplier }

procedure DoMult;

{propriété pour obtenir le résultat }

Property Res:integer read FRes; published property Val1:integer read FVal1 Write FVal1 default 1; {Opérande 1} property Val2:integer read FVal2 Write FVal2 default 1; {Opérande 2}

{événement}

Property OnTooBig:TNotifyEvent read FTooBig write FTooBig; end; {TMult} procedure Register; implementation

constructor TMult.Create(AOwner: TComponent);

BEGIN

inherited Create(AOwner);

FVal1 := 1;

FVal2 := 1; End;

procedure TMult.DoMult;

Begin if (Val1 < 100) and (Val2 < 100) then

FRes := FVal1 * FVal2 else if assigned(FTooBig) then OnTooBig(Self);

End;

procedure Register;

begin

RegisterComponents(’Samples’, [TMult]); end; end.

Pour obtenir le produit de deux nombres, le composant TMult s’appuie sur un processus peu élégant en deux étapes. Lorsque la valeur de Val1 ou Val2 est modifiée, Res doit être recalculé automatiquement. Pour ce faire, vous pouvez appeler une procédure dès que la propriété est modifiée, ou encore une fonction qui renvoie la valeur de la propriété dès que celle-ci est lue.

{ }

type

TMult = class(TComponent)

Private

FTooBig : TNotifyEvent;

FVal1 : integer;

FVal2 : integer;

FRes : integer;

{********** On déplace DoMult dans la zone Private *******} procedure DoMult;

{********** On ajoute la définition de SetVal1 et SetVal2 *******} procedure SetVal1(InVal : Integer); {Pour définir Value1} procedure SetVal2(InVal : Integer); {Pour définir Value2}

protected public

{Propriété pour obtenir le résultat } Property Res:integer read FRes;

constructor Create(AOwner : TComponent); override;

published

{********** méthodes d’accès set *******} property Val1:integer read FVal1 Write SetVal1 default 1; {Operand 1} property Val2:integer read FVal2 Write SetVal2 default 1; {Operand 2}

Property OnTooBig:TNotifyEvent read FTooBig write FTooBig; {Event} end; {TMult}

{ }

procedure TMult.SetVal1(InVal : Integer);

Begin

FVal1 := InVal;

DoMult; End;

procedure TMult.SetVal2(InVal : Integer);

Begin

FVal2 := InVal;

DoMult;

End;

{ }

end.

Dans le programme de test, vous n’avez plus besoin d’appeler la méthode DoMult. En fait, si vous tentez de le faire, l’application ne se compile pas car la méthode a été déplacée dans la partie privée. Les fonctionnalités demeurent inchangées pour le reste.

MODIFIER UN COMPOSANT DÉJÀ EXISTANT

TMult nous a permis d’aborder de nombreux concepts liés à la création d’un composant, mais pas de voir comment dériver un composant d’un déjà existant. L’un des grands avantages de la programmation orientée objet est qu’un objet peut être dérivé d’une classe ancêtre. Ainsi, par exemple, si vous souhaitez créer un composant qui soit un bouton vert, vous n’êtes pas obligé d’écrire tout le code qui crée un bouton et prévoit toutes les interactions possibles avec celui-ci. Un bouton générique existe déjà.

Dans l’exemple qui suit, nous allons créer un composant appelé TButClock. Il se comporte comme un bouton, à cela près que la propriété Caption est modifiée automatiquement pour contenir l’heure courante.

Pour construire un composant à partir d’un déjà existant, vous utilisez l’Expert composant pour créer son noyau et ajouter d’éventuelles nouvelles fonctionnalités. Pour cet exemple, on utilisera un thread qui sera placé dans une boucle jusqu’à destruction du composant. Le thread est en sommeil une seconde, puis appelle une fonction de callback dans le composant pour actualiser la caption avec l’heure courante.

Le composant TbutClock

unit unitTBC; interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,

StdCtrls, extctrls; type

{un type Callback pour que le thread puisse actualiser l’horloge }

TCaptionCallbackProc = procedure(X : String) of object;

{Objet Thread }

TUpdateClock = class(TThread) private procedure UpdateCaption;

protected procedure Execute; override;

public

UpdateClockProc : TCaptionCallbackProc; end;

{Composant principal } TButClock = class(TButton) private

{ Déclarations privées}

MainThread : TUpdateClock; procedure UpdateCaption(X : String);

protected

{ Déclarations protégées } public

{ Déclarations publiques }

constructor Create(AOwner : TComponent);override;

destructor destroy; override;

published

{ Déclarations publiées } end; procedure Register; implementation

{Cette routine appelle UpdateClockProc en lui fournissant l’heure correcte } procedure TUpdateClock.UpdateCaption; begin

UpdateClockProc(TimeToStr(Now)); end;

procedure TUpdateClock.Execute; begin

{On boucle jusqu’à ce qu’on nous dise de terminer, puis on sort } while (not Terminated) do begin

Synchronize(UpdateCaption);

Sleep(1000); end

end;

MainThread := TUpdateClock.Create(True);

{on définit le pointeur de callback }

MainThread.UpdateClockProc := UpdateCaption;

{On sort le thread du mode suspendu

MainThread.Resume; end;

{Appelé lors de la destruction du composant } destructor TButClock.Destroy; begin

{ on dit au thread de s’achever }

MainThread.Terminate;

{On attend la fin }

MainThread.WaitFor; { Nettoyage de TButClock} inherited Destroy;

end;

{On modifie le Caption lorsqu’on nous dit de le faire } procedure TButClock.UpdateCaption(X : String); begin

Caption := X; end;

procedure Register;

begin

RegisterComponents(’Samples’, [TButClock]); end; end.

L’analyse de ce code figure dans les parties qui suivent.

Le constructeur

Le constructeur commence par exécuter tout le code nécessaire provenant de son parent. En l’occurrence, l’objet est un descendant de TButton, il est donc important que le bouton procède aux allocations ou initialisations indispensables à son bon fonctionnement. Une fois que vous avez appelé le constructeur hérité, vous créez une instance de la classe de thread TupdateClock en appelant sa méthode create. Celle-ci est passée comme True pour indiquer que le thread doit être suspendu lors de sa création. Une fois ce dernier créé, vous devez procéder comme suit :

1.      Affectez la procédure UpdateCaption à la propriété UpdateClocProc du thread. Vous indiquez ainsi au thread ce qu’il doit faire lorsqu’il est temps d’actualiser le libellé du bouton.

2.      Sortez le thread du mode suspendu en appelant Resume, comme le montre le code ci-après :

constructor TButClock.Create(AOwner : TComponent); begin inherited Create(AOwner);

{on crée le thread en mode suspendu }

MainThread := TUpdateClock.Create(True);

{on définit le pointeur de callback }

MainThread.UpdateClockProc := UpdateCaption;

{on sort le thread du mode suspendu }

MainThread.Resume; end;

destructor TButClock.Destroy;

{appelé lors de la destruction du composant } begin

{ indique au thread de s’achever }

MainThread.Terminate;

{ on attend la fin }

MainThread.WaitFor; { Nettoyage de TButClock} inherited Destroy; end;

La procédure UpdateCaption

Le thread appelle UpdateCaption et lui passe Time pour actualiser le libellé, comme le montre le code ci-après (vous auriez tout aussi bien pu placer la logique liée à l’heure dans cette procédure) :

procedure TButClock.UpdateCaption(X : String); {On modifie le Caption lorsqu’on nous dit de le faire } begin

Caption := X; end;

La procédure Register

Vous achevez le composant avec la procédure Register, qui déclare que le composant TbutClock doit être placé sur la page Exemples de la VCL.

procedure Register;

begin

RegisterComponents(’Samples’, [TButClock]); end; end.

TButClock

Une fois que vous avez construit votre composant, il est prêt à l’emploi. Lorsque vous l’ajoutez à une forme lors de la conception, il donne l’heure avant même que le programme ne soit compilé. Vous n’avez pas modifié la fonctionnalité de la propriété Caption pour qu’elle puisse être lue : elle indique l’heure courante. Vous n’avez pas empêché l’utilisateur d’écrire dans le champ Caption. Tout ce qu’il écrit dans cette propriété sera remplacé par l’heure courante la prochaine fois que le thread inscrira la nouvelle heure.

Selon le type d’applications que vous concevez, le composant qui suit peut s’avérer utile. On est souvent amené à tracer une fonction mathématique. De nombreux composants vous permettent de créer un graphique en fournissant un ensemble de points, mais très peu vous permettent de fournir simplement la fonction à tracer. Ce composant sert à cela. Un événement appelé OnUserFunc est défini. Il passe une valeur X et attend qu’une valeur Y soir renvoyée. Les facteurs d’intervalle et d’échelle sont définis comme propriétés. Ainsi, si vous souhaitez tracer la fonction Y = X², vous ajoutez le composant à votre forme et le code ciaprès à l’événement OnUserFunc :

procedure TForm1.FuncGraph1UserFunc(X: Real; var Y: Real); begin

Y := X * X; end;

Le composant TFuncGraph gère toutes les mises à l’échelle et transforme les coordonnées. Vous n’avez en fait à taper qu’une seule ligne de code. Les exemples précédents vous ont montré comment en implémenter la plus grande partie. Le code complet de TFuncGraph figure ci-dessous. Les sections qui suivent mettent l’accent sur la méthode permettant de créer un nouveau type d’événement et sur la création d’un événement basé sur celui-ci.

Le composant TFuncGraph unit PlotChart; interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls,Forms, Dialogs;

type

TUserPlotFunc = procedure(X : real ; var Y : real) of object;

TFuncGraph = class(TGraphicControl) private

{ Déclarations privées }

FRangeMinX : integer;

FRangeMaxX : integer;

FRangeMinY : integer;

FRangeMaxY : integer;

FUserFunc : TUserPlotFunc; protected

{ Déclarations protégées } procedure paint; override;

public

{ Déclarations publiques }

constructor Create(Aowner : TComponent); override;

published

{ Déclarations publiées }

end;

procedure Register; implementation

constructor TFuncGraph.Create(Aowner : TComponent); begin

{on définit une largeur, une hauteur et un intervalle par défaut } inherited Create(AOwner);

Height := 50;

Width := 50;

FRangeMaxX := 1;

FRangeMaxY := 1; end;

procedure TFuncGraph.Paint; var

X,Y : integer; { pixels réels}

RX,RY : real; {coordonnées utilisateur } begin inherited Paint;

Canvas.Rectangle(0,0,Width,Height);

For X := 1 to Width do begin

{on convertit X en X utilisateur }

{Note : la largeur ne peut être 0}

RX := FRangeMinX + (((FRangeMaxX - FRangeMinX)/Width)*X);

{Si l’utilisateur a affecté une fonction de traçage } {on appelle cette fonction, sinon on affecte RY = 0 }

if assigned(FUserFunc) then

FUserFunc(RX,RY)

else

RY := 0;

{On reconvertit RY en coordonnées de pixel }

Y := round((1-((RY-FRangeMinY)/(FRangeMaxY-FRangeMinY)))*

Height);

if X = 1 then

Canvas.MoveTo(X,Y)

else

Canvas.LineTo(X,Y);

end;

end;

procedure Register;

begin

RegisterComponents(’Additional’, [TFuncGraph]); end;

end.

L’analyse de ce listing figure dans les parties qui suivent.

CRÉER UN NOUVEAU TYPE D’ÉVÉNEMENT

La fonctionnalité clé de ce composant est de permettre à l’utilisateur de définir une fonction arbitraire à tracer. Pour ce faire, vous implémentez un nouveau type d’événement, TUserPlocFunc, dont la définition est :

TUserPlotFunc = procedure(X : real ; var Y : real) of object;

Ce type est déclaré dans la partie type de l’unité. Notez que TUserPlotFunc est une procédure, ce qui peut sembler bizarre dans une section type. Cela signifie que vous pouvez déclarer une variable qui est un pointeur vers une procédure prenant les arguments spécifiés dans la déclaration de type. Une fois le type déclaré, vous définissez une propriété publiée de TuserPlotFunc pour créer un événement utilisant les paramètres définis précédemment :

Lorsque le composant est installé, un nouvel événement appelé OnUserFunc apparaît dans la liste. Si on double-clique dessus, Delphi crée une nouvelle procédure contenant les paramètres adéquats.

procedure TForm1.FuncGraph1UserFunc(X: Real; var Y: Real); begin end;

Appeler l’événement

Pour appeler le Gestionnaire d’événements à partir de votre composant, vous appelez la variable qui pointe sur la procédure et vous passez les paramètres adéquats. Assurez-vous qu’un événement valide est défini. Pour le savoir, appelez la fonction assigned. Voici un exemple d’appel à la fonction utilisateur :

if assigned(FUserFunc) then FUserFunc(RX,RY)

TFuncGraph

En ne tapant que huit lignes de code (voir ci-dessous), vous pouvez tracer quatre fonctions mathématiques.

Voilà ce qui s’appelle du développement rapide d’application.

Programme de test de TFuncGraph unit unitPlotApp; interface uses

Windows, Messages, SysUtils, Classes, Graphics, Controls,Forms, Dialogs, StdCtrls, PlotChart;

type

TForm1 = class(TForm)

FuncGraph4: TFuncGraph;

FuncGraph1: TFuncGraph;

FuncGraph2: TFuncGraph;

FuncGraph3: TFuncGraph;

Label1: TLabel;

Label2: TLabel;

Label3: TLabel;

Label4 TLabel;

Procedure FuncGraph1UserFunc(X: Real; var Y: Real); procedure FuncGraph3UserFunc(X: Real; var Y: Real); procedure FuncGraph4UserFunc(X: Real; var Y: Real); procedure FuncGraph2UserFunc(X: Real; var Y: Real);

private public end; var

Form1: TForm1;

implementation {$R *.DFM}

procedure TForm1.FuncGraph1UserFunc(X: Real; var Y: Real); begin

Y := X; end;

procedure TForm1.FuncGraph3UserFunc(X: Real; var Y: Real); begin

Y := Cos(X); end;

procedure TForm1.FuncGraph4UserFunc(X: Real; var Y: Real); begin

Y := Sin(X); end;

procedure TForm1.FuncGraph2UserFunc(X: Real; var Y: Real); begin

Y := sqrt(X); end; end.

Il existe trois types de composants :

Les composants non visuels ( tels TTable, TDataSource , etc ) qui ne sont en fait que des ensembles de fonctions.

Les composants visuels susceptibles de détenir le focus. Ces composants sont gérés par un handle par Windows et sont donc relativement gourmands en ressources.

Les composants visuels ne pouvant pas détenir le focus ( tels TLabel ou TShape ). Ce sont des dessins redessinés en permanence.

HIÉRARCHIE DES CLASSES DE COMPOSANTS

Lorsque l'on souhaite créer un composant il faut connaître parfaitement la hiérarchie des classes de composants ( elle même constituant un sous-ensemble de la bibliothèque des objets de DELPHI ) dans la mesure où tout composant créé doit dériver d'un composant existant.

Tous les composants dérivent de la classe générale TComponent qui possède les caractéristiques de base nécessaires ( comme la possibilité de s'intégrer dans la palette des composants ).

La plupart des composants de la palette dérivent de la classe TWinControl. Les composants graphiques ( sans handle ) dérivent quant à eux de TGraphicControl. Les composants non visuels dérivent de TComponent.

CREATION D’UNE ICÔNE SPECIFIQUE

Il est possible de créer une icône spécifique en utilisant pour cela l'éditeur d'icône proposé par DELPHI. Cette icône, au format bitmap, est considérée comme une ressource par DELPHI et est stockée dans un fichier dont l'extension est .DCR.

Pour créer une icône spécifique il faut donc réaliser les opérations suivantes :

1.   Ouvrir l'éditeur d'image ( menu Outils | Editeur d'image ).

2.   Dans l'éditeur , activer le menu Fichier | Nouveau. Une boite de dialogue apparaît où il faut sélectionner l'option 'Nouveau composant (.DCR )'.

La boîte de dialogue permettant de définir une nouvelle ressource de type bitmap.

4.   La validation du choix provoque l'affichage d'une nouvelle boite de dialogue dans laquelle il faut définir le nombre de couleurs utilisées et la taille de l'image à créer.

5.   Même si DELPHI préconise une taille de 24 x 24 pixels, il est préférable de se limiter à une image de 20 x 20 pixels de manière à préserver les bordures de la palette de composants.

6.   Au sortir de la boite de dialogue, un nom par défaut ( BITMAP_1 ) est donné à l'icône et l'éditeur d'image est ( enfin ) affiché.

7.   Créer l'image en utilisant les différents outils disponibles.

8.   Il est utile d'utiliser la possibilité de zoom ( X 4 ) proposé en haut à droite de l'éditeur.

9.   Lorsque l'icône est créée il faut sauvegarder le fichier de ressources, au format DCR, en respectant les conventions suivantes :

10.  Le fichier .DCR doit avoir le même nom que le fichier ( .PAS ou .DCU ) du composant.

11.  Le fichier .DCR doit être stocké dans le même répertoire que le fichier contenant le composant.

12.  Il faut enfin renommer la ressource incluse dans le fichier .DCR. Pour cela il faut :

13.  Revenir à la boîte de dialogue permettant d'accéder à tous les types de ressources ;

14.  Sélectionner la ressources BITMAP_1 concernée ;

15.  Activer le bouton 'Renommer' afin de donner à cette ressource le même nom que la classe du composant.

16.  Il ne faut utiliser que des lettres majuscules pour nommer la ressource.

17.  Sauvegarder le fichier .DCR modifié.

18.  Lors de la recompilation de la bibliothèque de composants, l'image est prise en compte et est affichée dans la palette de composants.

Exemple :

Si l'on a créé un composant dont la classe s'appelle TMonComposant et l'unité ( et donc les fichiers .PAS et .DCU ) s'appellent MonComp , il faut :

 DIFFUSION D'UN COMPOSANT :

Lorsque le composant est achevé il est possible de le diffuser auprès des utilisateurs.

La diffusion peut se faire sous deux formes :

Diffusion du fichier .PAS du composant et du fichier .DCR associé :

Dans ce cas l'utilisateur du composant a accès à son source et peut, éventuellement le modifier. Connaissant la structure interne du composant il peut facilement réaliser un composant spécifique dérivé du composant fourni.

Diffusion du fichier .DCU du composant et du fichier .DCR associé :

Dans ce cas l'utilisateur peut utiliser le composant tel quel mais aura plus de difficulté à créer un composant spécifique dérivé du composant fourni du fait qu'il ne connaît pas sa structure interne.

Dans les deux cas la procédure d'installation est la même : installation du composant générant la recompilation de la bibliothèque.

LES DIFFERENTS TYPES DE PROPRIÉTÉS

Une propriété peut être d'un des types de données du Pascal ou alors être un objet. Selon les cas elles apparaîtront de différentes formes dans l'inspecteur d'objet.

Type                                        Observations

Numérique ou Chaîne Apparaissent, sous format ASCII, dans une zone d'édition simple que l'on peut modifier directement

Enuméré                                Une liste de toutes les valeurs (booléennes ) que peut prendre la propriété apparaît dans l'inspecteur d'objets

Ensemble La propriété apparaît avec un '+' sur son coté gauche. Le fait de double-cliquer sur la propriété affiche alors toutes les valeurs disponibles que l'on peut alors traiter individuellement.

Création d'une propriété

Pour créer une propriété il faut utiliser le mot réservé 'property' selon la syntaxe suivante :

propertyNomPropriete : type read [ AccesLecture ] write [ AccesEcriture ] default valeur où :

Par tradition, si on ne réalise pas un accès direct à la donnée membre, la fonction de contrôle d'accès en lecture utilise le préfixe Get suivi du nom de la propriété et ne demande pas de paramètre. De même la procédure d'accès en écriture utilise le préfixe Set . et demande un paramètre d'un type permettant de modifier la donnée cible.

Seuls le nom de la propriété et son type sont obligatoires. Toutes les autres spécifications sont facultatives ( en particulier la clause 'default' ).

Cependant si on trouve souvent des propriétés qui ne sont accessibles qu'en lecture ( pas de clause 'write' ) il n'existe pratiquement pas de propriété qui ne sont accessibles qu'en écriture (pas de clauses 'read' ).

Le fait d'assigner une valeur par défaut à une propriété ne signifie pas qu'elle prendra cette valeur lors de la création du composant. Cela signifie simplement que si la valeur de la propriété a cette valeur lors de la conception d'une feuille, au sein d'un projet, il n'y aura pas de ligne référençant cette propriété dans le fichier .DFM associé. D'où économie lors de la génération du module objet ( et donc de l'exécutable ) associé.

Par contre il est souhaitable d'initialiser la propriété à sa valeur par défaut lors de l'exécution du constructeur du composant.

Il faut aussi que la propriété définisse une clause 'read' sinon elle n'apparaîtra pas dans l'inspecteur d'objet.

Les propriétés qui sont déclarées dans la section 'public' ne sont accessibles qu'à l'exécution.

Une propriété peut par ailleurs être définie dans la partie 'public' ou 'protected' de la classe. Dans ce cas elle n'apparaîtra pas dans l'inspecteur d'objet mais une classe dérivée à partir de cette classe pourra publier la propriété.

C'est sur ce principe que sont réalisées les classes des composants standards. Elles dérivent toutes d'une classe de plus haut niveau, de préfixe TCustom , dans laquelle les propriétés ne sont pas publiées. La classe du composant standard se contente de publier les propriétés désirées ( certaines propriétés pouvant rester non publiées ).

Le composant TListbox dérive ainsi de la classe TCustomListBox.

Pour publier une propriété, déclarée 'protected' dans le classe mère, il suffit de l'invoquer par son nom dans la section 'published' :

published

Color ;{ rend publiée une propriété définie dans la classe mère }

.;

Exemples de propriétés :

type

TCouleur = ( clRed, clWhite, clBlue, clGreen, clBlack ) ;

{ Définition d'un type énuméré }

TMaClasse = class ( TComponent )

private

FLongueur : integer ;

FChaine : string ; FCouleur : TCouleur ; function GetCouleur : TCouleur ; procedure SetCouleur ( couleur : TCouleur ) ; published property Longueur: integer read FLongueur write FLongueur default 20 ;

property Chaine : string read FChaine write FChaine ; property Couleur : TCouleur read GetCouleur write SetCouleur ;

end ;

function TMaClasse.GetCouleur : integer ; begin result := FCouleur ;

end ;

procedure TMaClasse.SetCouleur ( couleur : integer ) ; begin

FCouleur := couleur ; end ;

CONSTRUCTION ET DESTRUCTION D'UN COMPOSANT

Comme pour tout objet, la définition d'un composant implique celle d'un constructeur et d'un destructeur.

La détermination du propriétaire du composant se fait lors de l'exécution du constructeur de ce dernier : il est passé en paramètre au constructeur.

Si on ne veut pas qu'un autre composant soit propriétaire d'un composant créé, il suffit de transmettre Self (qui correspond à la fiche ) comme valeur du paramètre AOwner.

Le propriétaire du composant est chargé de le détruire le cas échéant. En particulier lorsque le propriétaire est détruit (par exemple lorsque la feuille est détruite ) c'est lui qui, automatiquement, détruit les composants dont il est propriétaire en appelant pour chacun d'entre eux leur méthode Free.

On peut connaître le parent d'un composant en invoquant la propriété Owner.

Parent d'un composant

Dans le cas d'un composant visuel il faut en outre définir un composant parent. Celui-ci est le composant dans lequel le composant créé va être affiché.

Seuls les composants "containers" peuvent être parents d'autres composants ( ex : TPanel, TGroupBox, etc . ).

Le propriétaire et le parent peuvent être différents.

Par exemple le propriétaire d'un composant peut ( c'est le cas général ) être la feuille alors que son parent peut être un composant Panel.

La détermination du composant parent se fait lors de l'exécution du constructeur du composant en initialisant sa propriété Parent.

Parent := self { le parent est le propriétaire }

ou

Parent := PAffiche { le parent est un composant de type Panel }

A partir du moment où on a défini un parent, les coordonnées ( propriétés Top et Left ) du composant créé sont définies à partir du coin haut / gauche du composant parent.

La deuxième caractéristique majeure d'un composant est son aptitude à réagir à des événements.

C'est ce qui se traduit par un code du type :

procedure TForm1.Button1Click (Sender: TObject); begin

                                                      { code définissant l'action à exécuter lorsque l'événement

                Click se                                  produit sur le composant Button1 }

end ;

A ce niveau il y aura lieu de distinguer :

-      Les événements standards, déjà pris en compte par la classe mère du composant ;

-      Ceux dont il serait souhaitable de modifier le comportement par défaut ;

-      Ceux qu'il faudra créer de toute pièce.

Il faudra surtout prendre en compte que si le concepteur de composant met à la disposition de l'utilisateur un certain nombre d'événements gérés, c'est l'utilisateur qui crée le gestionnaire d'événement associé. Le concepteur ne peut donc faire aucune présupposition sur l'action du gestionnaire d'événement. Il ne doit pas, en outre, empêcher, par une modification interne au composant, l'action du gestionnaire d'événement.

En première analyse, sauf à créer un composant de toute pièce, la plupart des composants standards définis dans les classes de base ont un comportement par défaut satisfaisant. Par ailleurs les principaux cas ( correspondant aux normes d'ergonomie de Windows ) sont pris en compte, on n'a donc que rarement l'occasion de souhaiter gérer un nouveau type d'événement.

Evénements standards :

La classe TControl définit le comportement d'un certain nombre d'événements, dits événements standards. Ces événements sont :

OnClick,         OnDblClick    OnDragDrop  OnDragOver OnEndDrag     OnMouseDown            OnMouseMove           OnMouseUp

OnEnter         OnExit                        OnKeyDown              OnKeyPress               OnKeyUp

Caractéristiques générales d'un événement

Un événement est un pointeur sur une méthode spécifique appartenant à une instance de composant donnée.

Du point de vue de l'utilisateur d'un composant, un événement est un nom associé à une méthode spécifique.

L'événement OnClick du composant Button1 est associé à la procédure Button1Click qui constitue le gestionnaire d'événement.

Lorsqu'une occurrence de l'événement 'click souris' se produit sur le composant Button1 c'est le gestionnaire d'événement Button1Click qui est exécuté.

Pour le concepteur de composant il va s'agir de fournir à l'utilisateur un moyen pour rattacher son code (le gestionnaire d'événement ) afin de le rendre en mesure de répondre aux occurrences d'événement.

Il ne faut pas perdre de vue que, dans tous les cas, un gestionnaire d'événement est facultatif. Le concepteur prévoit donc les événements qui seront gérés par le composant mais le code de ce dernier ne doit en aucun cas dépendre de la présence ou non d'un gestionnaire d'événement associé à un événement pour s'exécuter.

Implémentation sous DELPHI

Sous DELPHI, chaque événement géré par le composant (mis à la disposition de l'utilisateur pour qu'il puisse y rattacher le code d'un gestionnaire d'événement ) est accessible via une propriété spéciale servant d'interface d'accès ( en lecture et en écriture ) à une donnée d'un type particulier susceptible de pointer sur le gestionnaire d'événement "utilisateur" .

La donnée membre étant un pointeur sur une méthode (toujours de type procédure ), son type doit être indiqué précisément. La syntaxe générale de la déclaration d'un tel type est:

type

TPointeurMethode = procedure (paramètres de l'événement ) of object ;

Les différents paramètres doivent être conformes à ceux de la méthode pointée (même type, même nombre, même ordre ).

DELPHI propose, en standard, un certain nombre de type de "pointeurs sur une méthode", correspondant aux événements standards gérés.

TMouseMoveEvent :Utilisé pour les événements liés aux déplacements de la souris (OnMouseMove ).

Voir l'aide en ligne pour connaître le prototype de chacun de ces types de pointeur sur méthode.

La propriété "gestionnaire d'événement"

Pour accéder à la donnée membre, privée, il faut créer une propriété publiée qui doit avoir les caractéristiques suivantes:

•     Elle est de type "pointeur sur une méthode" (le même type que celui de la donnée membre associée ) ;

•     Elle n'utilise pas de méthode pour implémenter les parties 'read' et 'write'. Elle accède directement à la donnée privée.

Pour gérer un événement 'clic souris' on a alors le code :

type

TControl = class ( TComponent )

private

FOnClick : TNotifyEvent ; { définition du pointeur de méthode }

.

published property OnClick : TNotifyEvent read FOnClick write FOnClick;

end ;

Le seul fait que la propriété soit de type "pointeur sur une méthode" fait qu'elle est insérée dans le volet "événements" de l'inspecteur d'objet.

Si l'événement à gérer l'est déjà dans la classe de base, il n'y a pas lieu de recréer une nouvelle propriété ni même de définir un pointeur sur une méthode. Il suffit de publier celle du composant d'origine (dans le cas où cela n'a pas déjà été fait ) selon la syntaxe habituellement utilisée pour les autres propriétés :

published property OnClick ;

{ la propriété est publiée et donc l'événement OnClick est accessible dans l'inspecteur d'objet pour que l'utilisateur puisse créer le code du gestionnaire d'événement }

La méthode de gestion de l'événement

Le comportement de base de chaque composant à l'occurrence d'un événement est défini dans une méthode spécifique : chaque événement standard dispose donc d'une méthode de gestion appropriée définie dans la classe TControl ou TWinControl.

Par exemple il existe une méthode KeyDown, définie dans l'unité TWinControl pour assurer la gestion d'un appui sur une touche du clavier avec récupération, dans la variable Key, de la valeur de la touche utilisée.

De même il existe une méthode Click pour réagir aux événements OnClick, une méthode MouseMove pour gérer l'événement OnMouseMove, etc ..

Par contre la méthode associée à l'événement OnExit s'appelle DoExit.

Toutes sont méthodes sont protégées et sont virtuelles. Il est donc possible de les redéclarer dans le composant à créer si l'on souhaite modifier leur comportement par défaut.

Comment ça marche ?

1.      Lorsqu'un message est généré par Windows il est diffusé vers l'application active.

2.      Si le composant - actif à se moment là - contient une donnée membre de type pointeur sur une méthode (c'est à dire du type TNotifyEvent ou de ses dérivés ) compatible avec ce message, le mécanisme mis en place par DELPHI cherche, dans la table des méthodes du composant, celle qui a la même "signature" (même nombre et même types de paramètres ) que la donnée pointeur sur méthode et l'exécute.

3.      Au sein de cette méthode il y a test de la propriété On correspondant au type de message. Si la valeur de cette propriété est différente de Nil c'est que l'utilisateur final a écrit un gestionnaire d'événement. Celui-ci est alors exécuté.

4.      Le code particulier de la méthode de gestion de l'événement est exécuté (avant ou après celui de l'utilisateur selon les cas ).

S'il n'y a pas de méthode à la signature conforme, la recherche est faite dans les classes ascendantes.

Exemple :

Si l'on souhaite redéfinir, dans un composant dérivé de TEdit, la gestion par défaut de l'événement OnKeyDown de manière à ce qu'il élimine les espaces entrés au clavier il faut écrire le code suivant :

type

TMonEdit = class ( TCustomEdit )

private

..

protected

..

 procedure KeyPress ( var Key: Char ) ; override ;

.

published

..

OnKeyPress ;

                                        { publication de la propriété pour la rendre accessible à l'utilisateur }

end ;

procedure TMonEdit.KeyPress (var Key: char ); begin if Key = ' ' then

 Key := chr ( 0 ) ;

                                           inherited KeyPress ;

end ;

Dans certains cas, l'appel à la méthode originelle sera fait avant l'exécution du code assurant la modification du comportement par défaut. Dans d'autres, elle se fera après. C'est au concepteur de composant de choisir le déroulement le plus conforme à ses buts.

Il n'est pas nécessaire de définir des pointeurs sur les méthodes (ex : FOnKeyPress: TKeyPressEvent ), dans la partie privée de la classe, dans la mesure où ces pointeurs ont déjà été définis dans la classe de base et son accessible via la propriété On

Le concepteur défini ses propres événements

Dans ce dernier cas, le plus rare, le concepteur doit définir intégralement le mécanisme permettant de réaliser un événement proposé pour utilisation à un utilisateur.

Pour cela il doit :

-      Déterminer ce qui déclenche l'événement ;

-      Définir le type de gestionnaire ; -        Déclarer l'événement ; - Appeler l'événement.

Comme certaines de ces actions nécessitent des connaissances approfondies de la gestion des messages Windows, nous nous bornerons à indiquer brièvement les actions à entreprendre.

Détermination du message déclenchant l'événement

Il faut déterminer, dans la liste des messages Windows, lequel sera celui pris en compte comme déclencheur d'événement.

Pour cela il faut aller dans l'API Windows, rubrique 'messages (3.1)' afin de prendre connaissance de la liste des messages gérés par Windows.

Ces messages sont référencés sous la forme XX_YYY . où XX indique à quel type d'événement le message s'applique (BM : message vers un bouton, CB : vers une combo-box,

etc ) ;

Il faut ensuite connaître les différentes structures de messages définies par DELPHI pour prendre en compte, en les encapsulant, les messages Windows ( voir rubrique 'messages' de l'aide ).

Ces types correspondent à la définition de structures. Ils sont tous nommés TWM .

Pour cela on peut utiliser les types de pointeurs définis par DELPHI ( TNotifyEvent et autres ) ou alors créer sont propre type.

Déclaration de l'événement :

On peut alors déclarer la propriété pour l'événement, au type du pointeur sur une méthode déclaré précédemment.

Il faut respecter les règles de nommage afin que l'événement apparaissent dans l'inspecteur d'objet avec un nom qui soit dans la lignée des autres événements.

Appel du gestionnaire d'événement :

Il faut enfin créer le code du gestionnaire d'événement, écrit par l'utilisateur du composant, dans le cas où ce code existe.

En général le code d'appel à la forme suivante ( cas d'un gestionnaire associé à l'événement OnClick ) :

procedure TMonComposant.Click ; begin

If Assigned ( FOnClick ) then FOnClick ( self ) ;

.. { code spécifique mis en place par le concepteur } end ;

La méthode Assigned vérifie la valeur de la donnée FOnClick. Si cette donnée, de type pointeur sur méthode, a une valeur différente de Nil c'est que l'utilisateur du composant a créé un gestionnaire d'événement sur cet événement. Dans ce cas, le gestionnaire d'événement est appelé et exécuté, via la référence à FOnClick

Il se pose la question, comme dans un cas précédent, de savoir si le code spécifique prévu par le concepteur doit être exécuté avant ou après celui mis en place par l'utilisateur. Dans tous les cas :

- L'absence de "code utilisateur " ne doit pas empêcher l'exécution du code prévu par le concepteur ( d'où le test d'existence par Assigned ( ) ) . - Le code prévu par le concepteur ne doit pas influencer le code mis en place par l'utilisateur.

Exemple :

Voici le code utilisé par TControl pour gérer le message WM_LBUTTONDOWN (gestion des clics sur le bouton gauche de la souris ).

type

TControl = class ( Tcomponent )

private

FOnMouseDown : TMouseEvent;

procedure DoMousedown ( var message : TWXMouse ;

                                                    button : TMouseButton ; shift :TShifstate ) ;

{ ce prototype correspond au type TMouseEvent }

procedure WMLButtonDown ( var Message : TWMLButtonDown ) ;

 -> message WM_LBUTTONDOWN ;

protected procedure MouseDown ( button : TMouseButton ; shift :TShiftState ;  x , y : Integer ) ; dynamic ;

end ;

procedure TControl.MouseDown ( button : TMouseButton ;

shift : TShiftState ; x , y : integer ) ;

begin if Assigned ( FOnMousedown ) then

FOnMousedown ( self , shift , x , y ) ;

 { Appel du gestionnaire d'événement défini par l'utilisateur } end ;

procedure TControl.DoMousedown ( var Message : TWMMouse ; button : TMouseButton ; shift : TShiftState ) ;

begin with Message do

MouseDown ( button , KetToShiftState ( Keys ) + Shift , XPos, YPos ;

 { Appel de la méthode dynamique de gestion par défaut } end ;

                                procedure          TControl.WMLButtonDown          (var          Message          :

TWMLButtonDown ); begin inherited ;       { exécute la gestion par défaut } if csCaptureMouse in ControlStyle then

MouseCapture := True ; if csClickEvents in ControlStyle then

Include ( FControlState , csClicked ) ; DoMousedown ( Message , mbLeft, [ ] ) ;

{ appel de la méthode spécifique au contrôle } end ;

Dans une classe dérivée de TControl il faudra définir une propriété publiée OnMousedown permettant d'accéder à FOnMouseDown.

Cas particulier des événements qui n'utilisent pas les messages Windows Il peut arriver que l'événement créé ne s'appuie pas sur le mécanisme de message propre à Windows ( par exemple lorsqu'une condition vient à être satisfaite au sein du code }.

Les actions qui restent à réaliser sont alors :

1.      Déclaration d'un pointeur sur une méthode adéquat ( il s'agira la plupart du temps d'un pointeur sur une méthode ne nécessitant pas de paramètre, donc de type TNotifyEvent)

2.      Déclaration de la propriété associée On . .

3.      Création de la méthode protégée de gestion de l'événement. Cette méthode, comme dans le cas précédent, doit tester la valeur de la donnée pointeur pour, le cas échéant, exécuter le gestionnaire d'événement créé par l'utilisateur.

if Assigned ( FOnNonEvenement ) then FOnMonEvenement ( self ) ;

4.      Appeler cette méthode à partir des différentes procédures et fonctions du composant qui peuvent, lors de leur exécution, "déclencher l'événement".

LES COMMUNICATIONS SOUS TCP/IP

DELPHI permet de réaliser des interfaces graphiques, conformes aux normes Windows.

Cependant, de plus en plus, les utilisateurs ont besoins de s'échanger des informations ou de communiquer entre eux. Jusqu'à présent, Windows fournissait un certain nombre d'outils de communications, mais ceux-ci ne correspondent pas forcement à votre besoin.

Dans ce chapitre nous allons, en nous appuyant sur TCP/IP , voir les principes de la programmation système sous Windows et utiliser un composant orienté Communication sous

DELPHI.

Principes et outils de base ou ce qu'il faut savoir sur Windows avant d'utiliser les sockets

Historique

Permettre la communication entre des postes de travail Windows et des serveurs UNIX : telle est la raison d'être de l'API (Application Programmer Interface) Windows Sockets, connue également sous l'appellation winsock.

A la fin des années 1980, les premiers postes Windows connectés sur un réseau local accèdent principalement à des serveurs de fichiers et des imprimantes NETWARE. Pour y parvenir, ils utilisent le protocole IPX/SPX de Novell. Avec l'arrivée en force de l'architecture client - serveur, le PC est élu client par excellence du nouveau modèle. Son faible coût permet de le diffuser en masse, tandis que l'interface graphique séduit les utilisateurs. Intel et Microsoft prennent rapidement du poids en greffant également leurs produits aux serveurs sous UNIX. Pour cela, ils définissent un canal de communication s'appuyant sur TCP/IP, le protocole réseau utilisé par UNIX. Ainsi naît l'API Winsock. Empruntant les souliers d'UNIX, Windows trouve enfin une voie de normalisation des échanges entre les applications et la couche TCP/IP.

Les spécifications des winsock ayant fait l'unanimité, ils représentent aujourd'hui un standard incontesté. La croissance exponentielle de l'Internet trouve sa source dans les winsock, qui transforme des dizaines de millions de plates-formes Windows en autant de clients potentiels du réseau des réseaux.

UTILISATION DES SOCKETS SOUS WINDOWS

L'API WINDOWS ne dispose pas en standard des fonctions et procédures nécessaires pour utiliser les possibilités d'un protocole lors du développement d'une application.

Pour accéder au monde des communications, il faut installer une pile TCP/IP et s'appuyer sur les fonctions proposées par une DLL spécifique .

Version 1.1 : limitée à l'implantation de TCP/IP,

Version 2.0 : supporte un grand nombre d'autres protocoles

La version 32 bits est intégrée à Windows 95

Fournis sous la forme d'une librairie à liens dynamiques (DLL).

EXTENSION DES WINSOCK

La norme sous UNIX est d'émettre avec des appels bloquants (attente de connexion), ce qui n'est pas compatible avec les applications WINDOWS. Entraîne un blocage au niveau de l'interface utilisateur, Empêche le multitâche "coopératif" de Windows 3.11.

Les winsock supportent la notification asynchrone (par un message Windows) à la fin d'une connexion, d'une E/S socket,

Les Winsock offrent des extensions au sockets pour les rendre plus adaptées au mode d'envoi de message entre applications Windows

PHILOSOPHIE WINSOCK

Winsock 1.1 a été conçu pour Windows 16 bits

 multitâche coopératif (pas de thread)

Les opérations bloquantes sont supportées mais pas recommandées

Problème de portage de code :

porter un code bloquant traditionnel sous Windows est facile, mais pas recommandé

adapter un code bloquant au modèle de programmation Windows est difficile

UTILISATION DE LA WINSOCK

Avant d'utiliser les différentes fonctions de la , il est nécessaire de l'initialiser. Cela se fait en utilisant la fonction WSAStartup($101, info) avec :

info:WSADATA;

                $101: version de la dll (word)            correspond à la version 1.1 de la winsock

le deuxième argument retourne des informations sur le mode de transport