Introduction à l’environnement de développement intégré de Delphi

else     Caption := 'Haut'

  Caption := '';     elseif (I = 0) or (I in [10..99]) thenend;       Caption := 'Hors de l''intervalle'

else

         Caption := '';

Attention :

var i,x :byte;   i:=3;

..   case i of

    2..5 : x:=2;   case i of

    1..4 : x:=1;     1..4 : x:=1;   end;     2..5 : x:=2;

// ici x vaut 2 bien que 3 appartienne aussi àend;

l’intervalle 1..4, alors que // ici x vaut 1 bien que 3 appartienne aussi à

l’intervalle 2..5, seule le premier test valide i:=3; compte !

Voici d'autres exemples d'instructions case :

case MaCouleur ofcase Selection of   Rouge: X := 1;   Fin: Form1.Close;

  Vert: X := 2;   Calcul: CalculTotal(CourUnit, Quant);

  Bleu: X := 3; else

  Jaune, Orange, Noir: X := 0;   Beep; end; end;

                D.     La boucle Répéter

                1.            définition

L'instruction repeat a la syntaxe suivante : repeat instruction1; ; instructionn; until expression

où expression renvoie une valeur booléenne. Le dernier point-virgule avant until est facultatif. L'instruction repeat exécute répétitivement la séquence d'instructions qu'elle contient en testant expression à chaque itération. Quand expression renvoie True, l'instruction repeat s'arrête. La séquence est toujours exécutée au moins une fois car expression

n'est évaluée qu'après la première itération.

2.            exemples

repeat   K := I Mod J;

  I := J;   J := K; until J = 0;

E.        La boucle tant-que 

1.            définition

repeat

Write('Entrez une valeur (0..9): ');   Readln(I); until (I >= 0) and (I <= 9);

L'instruction while a la syntaxe suivante : while expression do instruction

où expression renvoie une valeur booléenne et instruction peut être une instruction composée. L'instruction while exécute répétitivement son instruction, en testant expression avant chaque itération. Tant que expression renvoie True, l'exécution se poursuit.

2.            exemples

while I > 0 dobeginwhilenot Eof(FicSource) dobegin

if Odd(I) then Z := Z * X;   Readln(FicSource, Ligne);

  I := I div 2;   Process(Ligne);

  X := Sqr(X); end;

end; while Data[I] <> X do I := I + 1;

F.      La boucle Pour

1.            définition

Une instruction for, à la différence des instructions repeat et while, nécessite la spécification explicite du nombre d'itérations que la boucle doit effectuer. L'instruction for a la syntaxe suivante : for compteur := valeurInitiale to valeurFinale do instruction ou

for compteur := valeurInitiale downto valeurFinale do instruction

où compteur est une variable locale (déclarée dans le bloc contenant l'instruction for) de type scalaire sans aucun qualificateur.

•  valeurInitiale et valeurFinale sont des expressions compatibles pour l'affectation avec compteur.

•  instruction est une instruction simple ou structurée qui ne modifie pas la valeur de compteur.

Afin de contrôler l'exécution de la boucle, la valeur des expressions valeurInitiale et valeurFinale n'est évaluée qu'une seule fois, avant le commencement de la boucle. Donc, une instruction forto est presque identique à la construction while suivante : begin

  compteur := valeurInitiale;

while compteur <= valeurFinale dobegin instruction;

    compteur := Succ(compteur);   end; end

La différence entre cette construction et l'instruction forto est que la boucle while réévalue valeurFinale avant chaque itération. Cela peut réduire la vitesse d'exécution de manière sensible si valeurFinale est une expression complexe. De plus, cela signifie qu'une modification de la valeur valeurFinale dans instruction peut affecter l'exécution de la boucle.

2.            exemples

for I := 2 to 63 doif Donnees[I] > Max then

    Max := Donnees[I];

for I := ListBox1.Items.Count - 1 downto 0 do     ListBox1.Items[I] := UpperCase(ListBox1.Items[I]);

for I := 1 to 10 do

for J := 1 to 10 dobegin     X := 0;

for K := 1 to 10 do

      X := X + Mat1[I, K] * Mat2[K, J];

    Mat[I, J] := X;   end;

for C := Red to Blue do Verif(C);

G.      Break, Exit  et Halt

•  Halt : Interrompt l'exécution du programme et rend le contrôle au système d'exploitation.

•  Exit : : Lorsque Exit est appelée dans un sous-programme (procédure ou fonction), elle induit un retour immédiat à l'appelant. Quand elle est appelée en tant qu'instruction du corps de programme principal, elle provoque la fin de l'exécution du programme.

Delphi et Kilix                                                                                      52                                                                            D. Mailliet

•  Continue : permet de reprendre un boucle interrompue.

                H.     Boucles infinies

Il va de soi  que si les instructions du corps de boucles ne modifie pas le test de boucle, on obtiendra une boucle infinie Pour réaliser volontairement une boucle Infinie, on peut utiliser l’une des structures:  ou encore:

RepeatWhile TRUE dobegin

// instructions// instructionsif <test> then break   if <test> then break

// instructions// instructions

until FALSE end{while}

                I.       Les Exceptions

Une exception est déclenchée quand une erreur ou un autre événement interrompt le déroulement normal d'un programme. L'exception transfère le contrôle à un gestionnaire d'exceptions, ce qui vous permet de séparer la logique normale d'exécution du programme de la gestion des erreurs. Comme les exceptions sont des objets, elles peuvent être regroupées en hiérarchies en utilisant l'héritage et de nouvelles exceptions peuvent être ajoutées sans affecter le code existant. Une exception peut véhiculer des informations, par exemple un message d'erreur, depuis le point où elle est déclenchée jusqu'au point où elle est gérée.

Quand une application utilise l'unité SysUtils, toutes les erreurs d'exécution sont automatiquement converties en exceptions. Les erreurs qui autrement provoqueraient l'arrêt d'une application (mémoire insuffisante, division par zéro, erreurs de protection générales) peuvent ainsi être interceptées et gérées.

                1.           Instructions Try except

Les exceptions sont gérées dans des instructions tryexcept. Par exemple :

try   X := Y/Z; except

on EZeroDivide do GereDivisionParZero; end;

Cette instruction tente de diviser Y par Z mais appelle la routine appelée GereDivisionParZero si une exception EZeroDivide est déclenchée.

L'instruction tryexcept a la syntaxe suivante :

else instructions

Un gestionnaire d'exception a la forme : on identificateur: typedo instruction

où identificateur: est facultatif (si identificateur est précisé, ce doit être un identificateur valide), type est le type utilisé pour représenter les exceptions et instruction est une instruction quelconque.

Une instruction tryexcept exécute les instructions dans la liste initiale instructions. Si aucune exception n'est déclenchée, le bloc exception (blocException) n'est pas pris en compte et le contrôle passe à l'instruction suivante du programme. Si une exception est déclenchée lors de l'exécution de la liste instructions initiale, que ce soit par une instruction raise dans la liste instructions ou par une procédure ou une fonction appelée dans la liste instructions, il va y avoir une tentative de "gestion" de l'exception :

Si un des gestionnaires du bloc exception ne correspond à l'exception, le contrôle passe au premier d'entre eux. Un gestionnaire d'exceptions "correspond" à une exception si le type du gestionnaire est la classe de l'exception ou un ancêtre de cette classe.

                Si aucun gestionnaire correspondant n'est trouvé, le contrôle passe à l'instruction de la clause else si elle est définie.

 Si le bloc d'exception est simplement une suite d'instructions sans gestionnaire d'exception, le contrôle passe à la première instruction de la liste.

Si aucune de ces conditions n'est respectée, la recherche continue dans le bloc exception de l'avant-dernière instruction tryexcept dans laquelle le flux du programme est entré et n'est pas encore sorti. Si, là encore, il n'y ni gestionnaire approprié, ni clause else, ni liste d'instructions, la recherche se propage à l'instruction en cours tryexcept précédente, etc.

Dans l'exemple suivant, le premier gestionnaire d'exceptions gère les exceptions division-par-zéro, le second gère les exceptions de débordement et le dernier gère toutes les autres exceptions mathématiques. EMathError apparaît en dernier dans le bloc exception car c'est l'ancêtre des deux autres classes d'exception : s'il apparaît en premier, les deux autres gestionnaires ne sont jamais utilisés.

try

except

on EZeroDivide do GereDivisionParZero;   on EOverflow do GereDebordement;   on EMathError do GereErreurMath; end;

Un gestionnaire d'exceptions peut spécifier un identificateur avant le nom de la classe exception. Cela déclare l'identificateur représentant l'objet exception pendant l'exécution de l'instruction suivant ondo. La portée de l'identificateur est limitée à celle de l'instruction. Par exemple :

try

except

on E: Exception do ErrorDialog(E.Message, E.HelpContext); end;

Si le bloc exception spécifie une clause else, la clause else gère toutes les exceptions qui ne sont pas gérées par les gestionnaires du bloc. Par exemple :

try

except

on EZeroDivide do GereDivisionParZero;   on EOverflow do GereDebordement;   on EMathError do GereErreurMath; else

  GereLesAutres; end;

Ici la clause else gère toutes les exceptions qui ne sont pas des erreurs mathématiques (EMathError).

Si le bloc exception ne contient pas de gestionnaires d'exceptions mais une liste d'instructions, cette liste gère toutes les exceptions. Par exemple :

try

except

  GereException; end;

Ici la routine GereException gère toutes les exceptions se produisant lors de l'exécution des instructions comprises entre try et except.

Redéclenchement d'exceptions

Par exemple, la fonction GetFileList alloue un objet TStringList et le remplit avec les noms de fichiers correspondant au chemin de recherche spécifié :

function GetFileList(const Path: string):     while I = 0 do

TStringList;     beginvar ();

  I: Integer;       I := FindNext(SearchRec);

  SearchRec: TSearchRec;     end; beginexcept

  Result := TStringList.Create;     ;

tryraise;

    I := FindFirst(Path, 0, SearchRec);   end;

end;

GetFileList crée un objet TStringList puis utilise les fonctions FindFirst et FindNext (définies dans SysUtils) pour l'initialiser. Si l'initialisation échoue (car le chemin d'initialisation est incorrect ou parce qu'il n'y a pas assez de mémoire pour remplir la liste de chaînes), c'est GetFileList qui doit libérer la nouvelle liste de chaînes car l'appelant ne connaît même pas son existence. C'est pour cela que l'initialisation de la liste de chaînes se fait dans une instruction tryexcept. Si une exception a lieu, le bloc exception de l'instruction libère la liste de chaînes puis redéclenche l'exception.

Exceptions imbriquées

Le code exécuté dans un gestionnaire d'exceptions peut lui aussi déclencher et gérer des exceptions. Tant que ces exceptions sont également gérées dans le gestionnaire d'exceptions, elles n'affectent pas l'exception initiale. Par contre, si une exception déclenchée dans un gestionnaire d'exceptions commence à se propager au-delà du gestionnaire, l'exception d'origine est perdue. Ce phénomène est illustré par la fonction Tan suivante.

type

  ETrigError = class(EMathError);

…

function Tan(X: Extended): Extended; begin

try

    Result := Sin(X) / Cos(X);   excepton EMathError do

raise ETrigError.Create('Argument incorrect pour Tan');   end; end;

                2.            Instructions try finally

Dans certains cas, il est indispensable que certaines parties d'une opération s'effectuent, que l'opération soit ou non interrompue par une exception. Si, par exemple, une routine prend le contrôle d'une ressource, il est souvent important que cette ressource soit libérée quelle que soit la manière dont la routine s'achève. Vous pouvez, dans ce genre de situations, utiliser une instruction tryfinally.

L'exemple suivant illustre comment du code qui ouvre et traite un fichier peut garantir que le fichier est fermé, même s'il y a une erreur à l'exécution.  Reset(F); try

// traiter le fichier Ffinally   CloseFile(F); end;

Une instruction tryfinally a la syntaxe suivante : try listeInstruction1 finally listeInstruction2 end

où chaque listeInstruction est une suite d'instructions délimitées par des points-virgule. L'instruction tryfinally exécute les instructions de listeInstruction1 (la clause try). Si listeInstruction1 se termine sans déclencher d'exception, listeInstruction2 (la clause finally) est exécutée. Si une exception est déclenchée lors de l'exécution de listeInstruction1, le contrôle est transféré à listeInstruction2 ; quand listeInstruction2 a fini de s'exécuter, l'exception est redéclenchée. Si un appel des procédures Exit, Break ou Continue force la sortie de listeInstruction1, listeInstruction2 est exécutée automatiquement. Ainsi, la clause finally est toujours exécutée quelle que soit la manière dont se termine l'exécution de la clause try.

Si une exception est déclenchée sans être gérée par la clause finally, cette exception se propage hors de l'instruction tryfinally et toute exception déjà déclenchée dans la clause try est perdue. La clause finally doit donc gérer toutes les exceptions déclenchées localement afin de ne pas perturber la propagation des autres exceptions.

L'unité SysUtils déclare plusieurs routines standard de gestion d'exceptions, dont ExceptObject, ExceptAddr et ShowException. SysUtils et d'autres unités de la VCL contiennent également de nombreuses classes d'exceptions qui dérivent toutes (sauf OutlineError) de Exception.

La classe Exception contient les propriétés Message et HelpContext qui peuvent être utilisées pour transmettre une description de l'erreur et un identificateur de contexte pour une aide contextuelle. Elle définit également divers constructeurs qui permettent de spécifier la description et l'identificateur de contexte de différentes manières. Pour davantage d'informations, voir l'aide en ligne.

J.      L’instruction with

Une instruction with est un raccourci permettant de référencer les champs d'un enregistrement ou les propriétés et méthodes d'un objet. L'instruction with a la syntaxe suivante  with obj do instruction ou 

with obj1, , objn do instruction

où obj est une référence de variable désignant un objet ou un enregistrement et instruction est une instruction simple ou structurée. A l'intérieur de instruction, vous pouvez faire référence aux champs, propriétés et méthodes de obj en utilisant seulement leur identificateur, sans utiliser de qualificateur.

Par exemple, étant donné les déclarations suivantes : type TDate = record

  Jour: Integer;

  Mois: Integer;   Annee: Integer;

end;

var DateCommande: TDate;

Vous pouvez écrire l'instruction with suivante :

with DateCommande do

if Mois = 12 thenbegin

    Mois := 1;

    Annee := Annee + 1;

Endelse

    Mois := Mois + 1; Qui est équivalente à 

if = 12 thenbegin

  := 1;

  DateCommande.Annee := DateCommande.Annee + 1; endelse

  := + 1;

Chaque référence de variable ou nom de méthode d'une instruction with est interprété, si c'est possible, comme un membre de l'objet ou de l'enregistrement spécifié. Pour désigner une autre variable ou méthode portant le même nom que celui auquel vous accédez avec l'instruction with, vous devez le préfixer avec un qualificateur comme dans l'exemple suivant : with DateCommande dobegin     Annee := Unit1.Annee

end;

Quand plusieurs objets ou enregistrements apparaissent après le mot réservé with, l'instruction est traité comme une série d'instructions with imbriquée. Ainsi  with obj1, obj2, , objn do instruction

est équivalent à 

with obj1 dowith obj2 do

with objn do        instruction

Dans ce cas, chaque référence de variable ou nom de méthode de instruction est interprété, si c'est possible, comme un membre de objn ; sinon, il est interprété, si c'est possible, comme un membre de objn–1; et ainsi de suite. La même règle s'applique pour l'interprétation même des objs : si objn est un membre de obj1 et de obj2, il est interprété comme .

                K.      Amélioration de la lisibilité

Afin de les rendre plus lisible, on s’inspirera des programmes ADA en terminant les structures par un commentaire de fin

de structure :

Function toto    end{toto} ; casewhilerecord toto  end{case}; end{while}; end{record}; // ouifbeginend{toto};

Withfor k

end{if}; end{with}; end{for k};

                1.            Blocs

Un bloc est composé d'une série de déclarations suivies d'une instruction composée. Toutes les déclarations doivent se trouver rassemblées au début du bloc. Un bloc a donc la forme suivante :

déclarationsbegin  instructionsend

La section déclarations peut contenir, dans un ordre quelconque, des déclarations de variables, de constantes (y compris des chaînes de ressource), de types, de procédures, de fonctions et de labels. Dans un bloc de programme, la section déclarations peut également contenir une ou plusieurs clauses exports (voir Bibliothèques de liaison dynamique et paquets).

Par exemple, dans la déclaration de fonction suivante :

function Majuscule (const S: string): string; var Ch: Char;   L: Integer;

  Source, Dest: PChar; begin

end;

La première ligne de la déclaration est l'en-tête de fonction et toutes les lignes suivantes constituent le bloc de la fonction. Ch, L, Source et Dest sont des variables locales ; leur déclaration n'est valable que dans le bloc de la fonction Majuscule et redéfinit (uniquement dans ce bloc) toute déclaration des mêmes identificateurs faite dans le bloc du programme ou dans les sections interface ou implémentation d'une unité.

Les règles déterminant la portée d'un identificateur sont résumées ci-dessous :

Si l'identificateur est déclaré dans             Sa portée s'étend

La déclaration d'un programme, d'une Depuis le point où il a été déclaré jusqu'à la fin du bloc en cours, y fonction ou d'une procédure. compris tous les blocs inclus dans cette portée.

La section interface d'une unité.                    Depuis le point où il a été déclaré jusqu'à la fin de l'unité et dans toutes les unités ou programmes utilisant cette unité. Voir Programmes et unités.)

La section implémentation d'une unité Depuis le point où il a été déclaré jusqu'à la fin de la section mais hors du bloc d'une fonction ou d'une implémentation. L'identificateur est disponible dans toutes les procédure. fonctions et procédures de la section implémentation.

La définition d'un type enregistrement Depuis le point où il a été déclaré jusqu'à la fin de la définition du

(c'est-à-dire que l'identificateur est le type de champ. Voir Enregistrements.) nom d'un champ de l'enregistrement).

La définition d'une classe (c'est-à-dire Depuis le point où il a été déclaré jusqu'à la fin de la définition du que l'identificateur est le nom d'une type classe et également dans les définitions des descendants de la propriété ou d'une méthode de la classe). classe et les blocs de toutes les méthodes de la classe et de ses descendants. Voir Classes et objets.

L'utilisation de plusieurs unités complique davantage la définition de portée. Chaque unité énumérée dans une clause uses impose une nouvelle portée qui inclut les unités restantes utilisées et le programme ou l'unité contenant la clause uses. La première unité d'une clause uses représente la portée la plus externe, et chaque unité successive représente une nouvelle portée interne à la précédente. Si plusieurs unités déclarent le même identificateur dans leur section interface, une référence sans qualificateur à l'identificateur sélectionne la déclaration effectuée dans la portée la plus externe, c'est-à-dire dans l'unité où la référence est faite, ou, si cette unité ne déclare pas l'identificateur dans la dernière unité de la clause uses qui déclare cet identificateur.

L'unité System est utilisée automatiquement par chaque programme et unité. Les déclarations de System ainsi que les types prédéfinis, les routines et les constantes reconnues automatiquement par le compilateur ont toujours la portée la plus extérieure.

Vous pouvez redéfinir ces règles de portée et court-circuiter une déclaration intérieure en utilisant un identificateur qualifié (voir Identificateurs qualifiés) ou une instruction with (voir Instructions with).

                4.           Identificateurs qualifiés

Quand vous utilisez un identificateur qui a été déclaré à plusieurs endroits, il est parfois nécessaire de qualifier l'identificateur. La syntaxe d'un identificateur qualifié est : identificateur1.identificateur2

où identificateur1 qualifie identificateur2. Si, par exemple, deux unités déclarent une variable appelée ValeurEnCours, vous pouvez désigner ValeurEnCours de Unit2 en écrivant :

Unit2.ValeurEncours

Il est possible de chaîner les qualificateurs. Par exemple :

Form1.Button1.Click

Appelle la méthode Click de Button1 dans Form1.

M.     Exercice

Reprendre l’étude de l’algorithme du tri rapide page 48

VII. Surcharge des routines

                1.            définition

Il est possible de redéclarer plusieurs fois une routine dans la même portée sous le même nom. C'est ce que l'on appelle la redéfinition (ou surcharge). Les routines redéfinies doiv

  Result := X/Y; end;

function Diviser(X, Y: Integer): Integer; overload; begin

  Result := X div Y; end;

Ces déclarations créent deux fonctions appelées toutes les deux Diviser qui attendent des paramètres de types différents. Quand vous appelez Diviser, le compilateur détermine la fonction à utiliser en examinant les paramètres effectivement transmis dans l'appel. Ainsi, Diviser(6.0, 3.0) appelle la première fonction Diviser car ses arguments sont des valeurs réelles.

Lorsqu'une routine est redéfinie, vous pouvez transmettre des paramètres qui ne sont pas de mêmes types que ceux des déclarations de la routine, mais qui sont compatibles pour l'affectation avec les paramètres de plus d'une déclaration. Par exemple, cela se produit très fréquement lorsqu'une routine est surchargée avec des types d'entiers différents ou des types de réels différents.

 procedure Store(X: Longint); overload;

 procedure Store(X: Shortint); overload;

Dans ces cas, lorsque cela est possible sans ambiguïté, le compilateur invoque la routine dont le type des paramètres a l'étendue la plus courte supportant les paramètres réels passés dans l'appel. (Souvenez-vous que les expressions constantes de valeur réelle sont toujours de type Extended.)

 function Maj(S: string): string; overload;

 procedure Maj(var Str: string); overload;

Alors que les déclarations :

 function Fonc(X: Real; Y: Integer): Real; overload;

 function Fonc(X: Integer; Y: Real): Real; overload;

  sont légales.

Quand une routine redéfinie est déclarée dans une déclaration forward ou d'interface, la déclaration de définition doit obligatoirement répéter la liste des paramètres de la routine.

Si vous utilisez des paramètres par défaut dans des routines redéfinies, méfiez-vous des signatures de paramètres ambiguës. Pour davantage d'informations, voir Paramètres par défaut et routines redéfinies.

Vous pouvez limiter les effets potentiels de la redéfinition en qualifiant le nom d'une routine lors de son appel. Par exemple, Unit1.MaProcedure(X, Y) n'appelle que les routines déclarées dans Unit1 ; si aucune routine de Unit1 ne correspond au nom et à la liste des paramètres, il y a une erreur de compilation.

Pour des informations sur la distribution de méthodes redéfinies dans une hiérarchie de classes, voir Redéfinition de méthodes. Pour plus d'informations sur l'exportation depuis une DLL de routines redéfinies, voir La clause exports de

l’aide Delphi.

2.            exemple

//Surcharge de la procédure val de l'unité systemfunction val(chn:string):real ; overload;

var err:integer ;  begin

    (chn,result,err);  // récupération de la// procédure d'origine. Val seulement ferait

//référence (récursive) à la fonctionend;

VIII. Exemples récapitulatifs

Ces 2 exemples traitent une liste de chaînes de caractères 

A.       exemple 1

Ce premier exemple utilise une variable globale (la liste) 

program strlst1; {$APPTYPE CONSOLE}

uses  dialogs;

Const  nl=#10#13;

 max=100; var               nb:word;              item:array[] ofstring;

procedure clear; Begin

  nb := 0 End;

End;

procedure delete (num:word);

var i :word; Beginfor i:= num to nb do item[i]:=item[i+1];     dec(nb); End;

procedure insert (num:word;chn:string); var i :word; Begin inc(nb);    for i:= nb downto num do item[i]:=item[i-1];    item[num]:= chn; End;

procedure exchange (pos1,pos2:word); var tmp:string; Begin      tmp := item[pos1];     item[pos1]:= item[pos2];     item[pos2]:= tmp;

End;

function getItem(ConstIndex: Integer): string; Begin      result := item[Index];

End ;

function toutTexte :  string; var indx : word; Begin

  result:='';   for indx:=1 to nb do     result := result+nl+item[indx];

End ;

function Find(const S: string; varIndex: Integer):   

Boolean;

{ Fonction qui recherche une chaîne S dans le tableau T la fonction renvoie  -  Vrai si S est dans T et la paramètre résultat Index contient l'adresse  -  Faux sinon et index contient n'importe quoi}

var  i : word ;

Begin

// A écrire

End ;

procedure sort() ;  // ou procedure sort;

{Trie les chaînes du tableau en ordre croissant}

Begin

// A écrire revoir le Qsort page 48

End;

program strlst2; {$APPTYPE CONSOLE}

uses  dialogs;

procedure clear (var t: TtabStr); Begin

with t do nb:=0  // ou plus simplement  t.nb :=

0

End;

procedure add (chn:string;var t: TtabStr);

Begin

with t dobegin// On pourrait ne pas utiliser with et     inc(nb);          // qualifier chaque champ : inc(t.nb);

    item[nb]:=chn;//  t.item[t.nb] := chnend;{with}End{add};

procedure delete (num:word;var t: TtabStr); var i :word; Beginwith t dobeginfor i:= num to nb do item[i]:=item[i+1];     dec(nb);   end{with}; End;{delete}

procedure insert (num:word;chn:string;var t:         

                     TtabStr);

var i :word;

Beginwith t dobegin     inc(nb);     for i:= nb downto num do       item[i]:=item[i-1];     item[num]:= chn;   end{with}; End;{insert}

procedure exchange (pos1,pos2:word;var :

                     TtabStr);

var tmp:string; Beginwith t dobegin     tmp := item[pos1];     item[pos1]:= item[pos2];     item[pos2]:= tmp;

end{with}; End;{exchange}

function getItem(ConstIndex: Integer; Const t:

TtabStr): string; Beginwith t do result := item[Index] // ou plus simplement : result := t.item[Index];

End{getItem};

var maListe:  TtabStr;

function toutTexte( Const t: TtabStr): string;

var indx : word; Begin

  result:='';   with t dofor indx:=1 to nb do     result := result+nl+item[indx]; End{toutTexte} ;

function Find(const S: string; Const T: TtabStr; varIndex: Integer): Boolean; { Fonction qui recherche une chaîne S dans le tableau T la fonction renvoie Vrai si S est dans T et la paramètre résultat Index contient l'adresse Faux sinon et index contient n'importe quoi}

var  i : word ;

Begin

// A écrire

End ;

procedure sort (var t: TtabStr); {Trie les chaines du tableau en ordre croissant}

Begin

// A écrire revoir le Qsort page 48

End;

BEGIN{ strlst2}    clear(maListe);

   Add('première ligne',maListe);

   Add('toisième ligne',maListe);

   ShowMessage('utilisation de la fonction :'+nl+nl+toutTexte(maListe));    writeln( 'utilisation du champ : chaîne d''indice 1:'[1]);    writeln;

   writeln('remarquer les lettres accentuées en mode console et fenêtré'); 

   ShowMessage('utilisation de la fonction :chaîne d''indice 1'+nl+nl+GetItem(1,maListe));    insert(3,'ligne 2 bis',maListe);

   ShowMessage('utilisation de la fonction :'+nl+nl+toutTexte(maListe)); END.

IX. Structure de données orientée objet

A.      Terminologie

Une classe (un type classe) définit une structure composée de champs, de méthodes et de propriétés.

Les instances d'un type classe sont appelées des objets.

Les champs, méthodes et propriétés d'une classe sont appelés ses composants ou ses membres.

Un champ est essentiellement une variable faisant partie d'un objet. Comme les champs d'un enregistrement, un champ de classe représente des éléments de données qui existent dans chaque instance de la classe.

Une méthode est une procédure ou une fonction associée à la classe. La plupart des méthodes portent sur des objets, c'està-dire sur des instances d'une classe. Certaines méthodes, appelées méthodes de classe, portent sur les types classe même.

Une propriété est une interface avec les données associées à un objet (souvent stockées dans un champ). Les propriétés ont des spécificateurs d'accès qui déterminent comment leurs données sont lues et modifiées. Pour le reste d'un programme (hors de l'objet même), une propriété apparaît à bien des points de vue comme un champ.

Une variable de type classe est en fait un pointeur qui référence un objet. Plusieurs variables peuvent donc désigner le même objet. Comme les autres pointeurs, les variables de type classe peuvent contenir la valeur nil. Cependant, il n'est pas nécessaire de déréférencer explicitement une variable de type classe pour accéder à l'objet qu'elle désigne. Par exemple, UnObjet.Taille := 100 affecte la valeur 100 à la propriété Taille de l'objet référencé, UnObjet ; vous ne devez pas l'écrire sous la forme UnObjet^.Taille := 100.

Un type classe doit être déclaré et nommé avant de pouvoir être instancié. Il n'est donc pas possible de définir un type classe dans une déclaration de variable. 

Déclarez les classes uniquement dans la portée la plus large d'un programme ou d'une unité, mais pas dans une déclaration de procédure ou de fonction.

La déclaration d'un type classe a la forme suivante :

type nomClasse = class (classeAncêtre)   listeMembre  end;

où nomClasse est un identificateur valide, (classeAncêtre) est facultatif et listeMembre déclare les membres (les champs, méthodes et propriétés) de la classe. Si vous omettez (classeAncêtre), la nouvelle classe hérite directement de la classe prédéfinie TObject. Si vous précisez (classeAncêtre) en laissant vide listeMembre, vous pouvez omettre le end final. Une déclaration de type classe peut également contenir une liste des interfaces implémentées par la classe ; voir Implémentation des interfaces.

Les méthodes apparaissent dans une déclaration de classe sous la forme d'en-tête de fonction ou de procédure sans le corps. La déclaration de définition de chaque méthode est faite ailleurs dans le programme. Quand vous déclarez une classe, vous pouvez spécifier son ancêtre immédiat. Par exemple :

type TUnControle = class(TWinControl);

La portée de l'identificateur d'un membre commence à l'endroit où le membre est déclaré et se poursuit jusqu'à la fin de la déclaration de la classe et s'étend à tous les descendants de la classe et les blocs de toutes les méthodes définies dans la classe et ses descendants.

                B.     TObject et TClass

La classe TObject, déclarée dans l'unité System, est l'ancêtre ultime de toutes les autres classes. TObject définit seulement quelques méthodes, dont un constructeur et un destructeur de base. Outre la classe TObject, l'unité System déclare le type référence de classe TClass : TClass = classof TObject;

Quand la déclaration d'un type classe ne spécifie pas d'ancêtre, la classe hérite directement de TObject. Donc : type TMaClasse = class

end; est équivalent à : type TMaClasse = class(TObject)

end;

C.      Exemple

Reprenons l’exemple page 61 des listes de chaînes utilisant un record et changeons ce mot en class (les seuls changements apparaissent en gras):

program strlst3;              item:array[] ofstring;

{$APPTYPE CONSOLE}end{class};

// Idem à strlst2uses  dialogs; 

BEGIN

Const   maListe:= TtabStr.create;// instancions l’objet nl=#10#13;    clear(maListe); 

 max=100; // Idem à strlst2

type TtabStr =class   maListe.destroy//  libérons la mémoirenb:word; END.

Remarques

Dans l’exemple précédent on utilise le constructeur create des Tobject

create est toujours qualifié par une classe et non par l’objet alors que destroy est qualifié par l’objet

D.      Compatibilité des types classe

Un type classe est compatible pour l'affectation avec ses ancêtres. Une variable d'un type classe peut donc référencer une instance de tout type descendant. Par exemple, étant donné la déclaration :

type

  TFigure = class(TObject);   TRectangle = class(TFigure); TCarre = class(TRectangle); var

E.      Visibilité des membres de classes

Chaque membre d'une classe a un attribut appelé visibilité, indiqué par l'un des mots réservés suivants : private, protected, public, published ou automated. Par exemple :

publishedproperty Couleur: TColor read LitCouleur write EcritCouleur;

déclare une propriété publiée appelée Couleur. La visibilité détermine où et comment il est possible d'accéder à un membre

:  private (privée) représente l'accès minimum, ==> Ne sont accessibles que par les instances de la classe elle-même.

protected (protégée) représente un niveau intermédiaire d'accès, ==> Sont accessibles par les instances de la classe ellemême et par les instances des classes dérivées de la classe en question.

public (publique), published (publiée) ==> Sont accessibles par toutes les instances de les toutes classes

automated (automatisée) représentant l'accès le plus large. ==> Sont accessibles par toutes les instances de les toutes classes et par l’inspecteur d’objet.

Si la déclaration d'un membre ne spécifie pas sa visibilité, le membre a la même visibilité que celui qui le précède. Les membres au début de la déclaration d'une classe dont la visibilité n'est pas spécifiée sont par défaut publiés si la classe a été compilée dans l'état {$M+} ou si elle dérive d'une classe compilée à l'état {$M+} ; sinon ces membres sont publics.

Dans un souci de lisibilité, il est préférable d'organiser la déclaration d'une classe en fonction de la visibilité, en plaçant tous les membres privés ensemble, suivis de tous les membres protégés, etc. De cette manière, chaque mot réservé spécifiant la visibilité apparaît au maximum une fois et marque le début d'une nouvelle "section" de la déclaration. Une déclaration de classe standard doit donc avoir la forme : type

  TMaClasse = class(TControl)   private

{ déclarations privées}protected

{ déclarations publiques }published

{ déclarations publiées }end;

Vous pouvez augmenter la visibilité d'un membre dans une classe dérivée en le redéclarant, mais il n'est pas possible de réduire sa visibilité. Par exemple, une propriété protégée peut être rendue publique dans un descendant mais pas privée. De plus, les membres publiés ne peuvent devenir publics dans une classe dérivée. Pour davantage d'informations, voir Surcharge et redéclaration de propriétés.

                F.      Constructeurs et destructeurs

Comme pour les objets, la mémoire est allouée dynamiquement. Pour les pointeurs, on utilise l’instruction new ou getmem lorsque l’on veut allouer de la mémoire et dispose ou freemem pour la libérer. Pour les objets, on utilise des méthodes spéciales que l’on appelle constructeur (que l’on nomme généralement create) et  destructeur (que l’on nomme généralement destroy). Et au lieu de procedure et function comme pour les autres méthodes, on utilise constructor et destructor.

                G.     Exemple

Revenons sur l’exemple de la liste de chaînes (page 61) avec une version objet

program strlst5;   {$APPTYPE CONSOLE}

uses    dialogs;

Const  nl=#10#13; max=100; type TtabStr =class nb:word;                 item:array[] ofstring; constructor Create ;                 procedure clear ;                 procedure add (chn:string);                 procedure delete (num:word);

procedure insert (num:word;chn:string);                 procedure exchange (pos1,pos2:word);                 function getItem(ConstIndex: Integer): string;                 function toutTexte : string; function Find(const S: string;  varIndex: Integer): Boolean;                 procedure sort (); // les () sont facultatives comme pour

constructor TtabStr.Create () ;

BeginInherited Create;   clear;

End;

procedure TtabStr.clear; Begin   nb:=0 End;

procedure (chn:string); Begin

  inc(nb);   item[nb]:=chn; End;

procedure TtabStr.delete (num:word);

var i :word; Beginfor i:= num to nb do item[i]:=item[i+1];   dec(nb);

End;

procedure TtabStr.insert (num:word;chn:string);

var i :word; Begin

  inc(nb);   for i:= nb downto num do item[i]:=item[i-1];   item[num]:= chn;

End;

procedure TtabStr.exchange (pos1,pos2:word);

var tmp:string; Begin   tmp :=  item[pos1];   item[pos1]:= item[pos2];   item[pos2]:= tmp;

End;

function TtabStr.getItem(ConstIndex: Integer):

string; Begin   result := item[Index];

End ;

function TtabStr.toutTexte: string; var indx : word; Begin

  result:='';   for indx:=1 to nb do result := result+nl+item[indx]; End ;

function (const S: string;  varIndex:

Integer): Boolean;

{ Fonction qui recherche une chaîne S dans le tableau T la fonction renvoie   -  Vrai si S est dans T et le paramètre résultat

Index contient l'adresse

  -  Faux sinon et index contient n'importe quoi}

var  i : word ;

Begin

// A écrire

End ;

procedure ();

{Trie les chaînes du tableau en ordre croissant}

Begin

// A écrire revoir le Qsort page 48

End;

var maListe:  TtabStr;

BEGIN concat;    maListe:= TtabStr.create; //Maintenant le constructeur initialise aussi nb. La 2ème ligne clear est donc inutile.

   ('première ligne');    ('deuxième ligne');    ('toisième ligne');    ShowMessage('utilisation de la fonction :'+nl+nl+maListe.toutTexte);    writeln( 'util

   ShowMessage('aprés utilisation de echange :'+nl+nl+maListe.toutTexte);    maListe.delete(2);

   ShowMessage('après utilisation de delete

:'+nl+nl+maListe.toutTexte);    maListe.destroy END.    maListe:=TStringList.create; ('première ligne');    ('deuxième ligne'); ('toisième ligne');    writeln( 'utilisation de la propriété :');    ShowMessage('utilisation de la propriété :'); ShowMessage('utilisation de la fonction :'+nl+nl+maListe.GetText);

2.            Exemple 2

program tst_form;

uses   Forms,stdctrls;

var   maForm:tform;   MonBouton  :  TButton;

begin

  Application.Initialize;    ShowMessage('chaîne d''indice 0 :

'+nl+nl+maListe.Strings[0]);    := 'tout le texte est changé';

   ShowMessage('utilisation de la propriété

:');

   ShowMessage('chaîne d''indice 0 : '+nl+nl+maListe.Strings[0]); end.

  :=100;   maForm.height:=300;   maForm.width:=400; maForm.caption := 'nouvelle fiche';   MonBouton := TButton.Create(maForm);   with MonBouton dobegin     Parent := maForm;     top := 20;     left := 20;     height := 20;     width := 200;     caption := 'nouveau bouton';

  Application.CreateForm(TForm, maForm);   end;

  maForm.visible := true;   ;   :=30; end.

Remarques et commentaires :

Il ne s’agit plus ici d’une application console, mais un simple éditeur et la compilation avec DCC32 suffisent.

Delphi 

Application est une variable de typeTapplication définie automatiquement par Delphi. Les 3 lignes :

Application.Initialize; Application.CreateForm(TForm, maForm); et ; seront automatiquement générée par l’EDI et feront partie du programme principal (fichier .DPR) menu :Projet/Voir le source

Tapplication et Tform sont définis dans l’unité Forms et Tbutton dans l’unité stdctrls

Nous aurions pu mettre maForm « en facteur » avec with comme c’est fait pour monBouton

Les propriétés top, left, height, width, caption sont en général définies dans l’inspecteur d’objet (voir page 72) et non dans le code du programme : on peut leur donner une valeur numérique au clavier ou déplacer visuellement les objets

Les coordonnées top et left du coin supérieur gauche sont données à partir du coin supérieur gauche de l’écran, celles du bouton à partir du coin supérieur gauche de la fiche (le propriéraire TButton.Create(maForm) et parent  Parent := maForm)

                3.           Exemple 3

Reprenons l’exemple 2 sans déclarer de variable MonBouton :

program tst_form; 

begin

uses   Application.Initialize;

  Forms,stdctrls;   Application.CreateForm(TForm, maForm);

   maForm.visible := true; var   :=30; maForm:tform;   :=100;

   maForm.height:=300;

  maForm.width:=400;     height := 20;

  maForm.caption := 'nouvelle fiche';     width := 200;

with TButton.Create(maForm) dobegin caption := 'nouveau bouton';

    Parent := maForm;   end;     top := 20;   ;     left := 20; end.

4.            Exemple 4

Cela se complique, si l’on veut faire de même avec la form : en effet, l’objet application gère automatiquement la création et la destruction de la forme ainsi que de tous les objets créés par l’application 

program tst_form;      top:=30; {$APPTYPE CONSOLE}     left:=100;

  Forms,stdctrls;     caption := 'nouvelle fiche';

end;

begin   readln;   with Tform.create(nil) dobeginend.      visible := true;

Remarquons ici qu’il s’agit d’une application console et la présence du readln.

Sans ce Readln, l’absence de  Application.Initialize; Application.CreateForm(TForm, maForm); ; terminerait le programme dès la fin de la création de la fiche et donc on ne verrait rien.

L’absence de nom à la fiche (pas de déclaration de variable) empêche d’y placer un élémént visuel par exemple un bouton comme précédemment, faute de pouvoir nommer propriétaire er parent. 

I.       Constitution des fichiers DPR, DMF, PAS

Créons un nouveau projet. Nommons la fiche « nouvelle  fiche » plaçons y un bouton que l’on nommera « nouveau bouton », nous obtenons quelquechose comme ceci : 

Un click droit sur cette fiche fait apparaître :

Choisissons voir comme du texte, nos observons le texte suivant :

object Form1: TForm1   OldCreateOrder = False

  Left = 100   PixelsPerInch = 96

  Top = 30   TextHeight = 13

  Width = 400   object Button1: TButton

  Height = 300     Left = 20

  Caption = 'nouvelle fiche'     Top = 20

  Color = clBtnFace     Width = 200

  Font.Charset = DEFAULT_CHARSET     Height = 20

  Font.Color = clWindowText     Caption = 'nouveau bouton'

  Font.Height = -11     TabOrder = 0

  = 'MS Sans Serif'   end

  Font.Style = [] end

Si nous comparons à l’exemple précédent, nous remarquons une hiérarchie comparable à l’exemple 2 ci-dessus. Bien entendu, l’absence de points-virgules et de := montre qu’il ne s’agit pas de code delphi, mais de description des objets visuels : cest ce que contient le fichier .DFM (Delphi ForM) 

Les objets sont des structures pour la plupart très complexes dans le sens où ils possèdent un nombre important de méthodes, de variables et de propriétés. Mettez-vous un instant à la place d'un programmeur chevronné et imaginez par exemple tout ce qu'il faut pour faire fonctionner un simple bouton : il faut entre autres le dessiner, réagir au clavier, à la souris, s'adapter en fonction des propriétés. C'est une tâche qui nécessite un volume impressionnant de code Pascal Objet.

première possède absolument tout ce qui est défini par la seconde : c'est l'héritage. La classe « descendante » est plus puissante que la classe « parente » dans le sens où de nouvelles méthodes, variables et propriétés sont généralement ajoutées ou modifiées. On dit dans ce cas que l’ondérive la classe parente.

                Delphi et Kilix                                                                                     69                                                                            D. Mailliet

Une telle hiérarchie impose l'existence d'un unique ancêtre ultime qui n'a pas de parent : c'est la classe « TObject » (qui possède un nom quelque peu embrouillant). De cette classe descendent TOUTES les classes existantes sous Delphi, et ceci plus ou moins directement (toutes les classes ne sont pas des descendantes directes de TObject mais sont souvent des descendantes de descendantes de de « TObject ». Cette dernière définit les mécanismes de base du fonctionnement d'un objet. Tous les objets sous Delphi sont d'une classe descendante de TObject, et possèdent donc tout ce que définit TObject, à savoir le minimum. 

Voici (une partie de ) l’arbre représentant la hiérarchie des classes Delphi:

B.      Exemple

Dans cet exemple, nous allons dériver un Tlist pour réaliser une liste de réels:

unit U_ListReal;

(* ----------------------------------------------------

    Implémentation (partielle) d'une liste de réels

    Sur le modèle des TstringList

   ----------------------------------------------------*)

interfaceuses classes;

type  tmaliste =class(Tlist) constructor Create ;      destructor Destroy;      function Add(Item: real): Integer;      function getitem(Index:Integer):real ;          // devrait être dans la zone privateprocedure setitem(Index:Integer;Item: real);   

// devrait être dans la zone privateprivate

{ Déclarations privées }protected

{ Déclarations protégées }public

{ Déclarations publiques }property Items[Index: Integer]:real read getitem write setitem;

published{ Déclarations publiées }end;

implementation

C.      Suite de l’exemple

constructor tmaliste.create; begin

Inherited Create;

end;

destructor tmaliste.Destroy; begin

Inherited Destroy;

end;

function (Item: real): Integer; var p :^real; begin    new(p); p^:=Item ;    Result:= inherited add(p); end;

function tmaliste.getitem(index:Integer):real ; begin

  result := real(inherited Items[index]^) ; end;

procedure tmaliste.setitem(Index:Integer;Item:

real);

begin

  real(inherited Items[index]^) := item end;

end.

Nous allons améliorer l’exemple en fournissant une procédure de tri de la liste des réels ; Tout est prévu dans Delphi:

Il suffit de définir une relation d’ordre par le biais d’une fonction : l’aide de Delphi indique pour :

Trie la liste, en employant l'algorithme Tri Rapide (QuickSort) et en utilisant Compare comme fonction de comparaison.  type TListSortCompare = function (Item1, Item2: Pointer): Integer; procedure Sort(Compare: TListSortCompare); Description

function cmpUp(Item1, Item2: Pointer): Integer;    result := -cmpUp(Item1, Item2);

beginend;

if(real(Item1^))>(real(Item2^)) thenprocedure tmaliste.triUp;

     result := 1 begin

elseif (real(Item1^))=(real(Item2^)) then sort(cmpUp)

     result := 0 end;

else

     result := -1 procedure tmaliste.triDn;

end; begin

   sort(cmpDn)

function cmpDn(Item1, Item2: Pointer): Integer; end; begin

                D.      Méthodes statiques, virtuelles et dynamiques ou abstraites

Ceci sera vu plus loin dans ce cours (Notions avancées sur les objets), mais pour plus d’information consulter l’aide Delphi :

Sommaire de l’aide/ Référence Pascal Objet/ Classes et objets/ Méthodes/ Liaisons de méthodes

XI. La programmation visuelle : l’EDI et la VCL 

                A.      Utilisation

Environnement de développement intégré et la librairie de composants visuels. On les obtient directement par les onglets :

Un click sur le composant et un click sur la forme permettent de le sélectionner puis ensuite de le positionner.

B.       Programme le plus simple avec l’EDI

Il n’y a aucun code à écrire : le simple fait d’ouvrir une nouvelle application, de la compiler et de l’exécuter, suffit à créer un exécutable ouvrant une fiche qui réagit aux événements d’agrandissement, dimensionnement, fermeture etc.…  L’exécutable produit à quand même une taille de 353 ko

C.     API Windows

Le programme suivant fait exactement la même chose, mais n’utilise que l’API Windows : 

program Window1;

{ Application Standard API Windows  écrite en Pascal Objet.Aucun code VCL inclu. Tout est fait au niveau de l'API Windows  .Il faut quand même inclure Windows et Messages!}uses   Windows,  Messages;

const AppName = 'Window1';

function WindowProc(Window: HWnd; AMessage, WParam,

       Exit;     end;

end;

  WindowProc := DefWindowProc(Window, AMessage, WParam, LParam); end;

{ enregistrer la Classe Window  }function WinRegister: Boolean; var WindowClass: TWndClass; begin

  WindowClass.Style := cs_hRedraw or cs_vRedraw;

  WindowClass.lpfnWndProc := @WindowProc;

  WindowClass.cbClsExtra := 0;   WindowClass.cbWndExtra := 0;

  WindowClass.hInstance := HInstance;   WindowClass.hIcon := LoadIcon(0, idi_Application);

  WindowClass.hCursor := LoadCursor(0, idc_Arrow);

  WindowClass.hbrBackground :=

HBrush(Color_Window);

  WindowClass.lpszMenuName := nil; WindowClass.lpszClassName := AppName;   Result := RegisterClass(WindowClass) <> 0; end;

{ Créer la Class Window  }function WinCreate: HWnd; var hWindow: HWnd; begin

  hWindow := CreateWindow(AppName,

'Fenêtre en Pascal Objet',   ws_OverlappedWindow, cw_UseDefault, cw_UseDefault,

  cw_UseDefault, cw_UseDefault, 0, 0, HInstance, nil);   if hWindow <> 0 thenbegin      ShowWindow(hWindow, CmdShow);      UpdateWindow(hWindow);   end;   Result := hWindow;

end;

var AMessage: TMsg;     hWindow: HWnd; beginifnot WinRegister thenbegin      MessageBox(0, 'l''enregistrement à échoué', nil, mb_Ok);

     Exit;   end;   hWindow := WinCreate;   if hWindow = 0 thenbegin      MessageBox(0, 'WinCreate a échoué', nil, mb_Ok);

     Exit;   end;

while GetMessage(AMessage, 0, 0, 0) dobegin

    TranslateMessage(AMessage);     DispatchMessage(AMessage); end;

  Halt(AMessage.wParam); end.

Il est beaucoup plus long, mais il peut s’écrire avec un simple éditeur et se compiler avec DCC32 : il ne prendra que 9,5 ko !!!soit 37 fois moins de place !!

XII. Composants usuels

Tous les composants ont une propriété name : celle-ci ne sera donc pas répétée à chaque fois.

                A.      La fiche : Composant "Form"

                1.            Caractèristiques

C'est LE composant conteneur classique qu'on utilise le plus souvent sans se rendre compte de cette fonctionalité

pourtant indispensable. 

Une fiche devient active quand elle obtient la focalisation, par exemple quand l'utilisateur clique dans la fiche

Se produit à la création de la fiche.

procedure              (Sender:           TObject); begin

showmessage('hello')

end; 

La méthode test appelée par onActivate produira un affichage au dessus de la form

La même méthode appelée par onCreate produira un affichage avant que la form ne soit affichée.

Se produit quand la fiche est redessinée.(très souvent!)

Se produit quand la fiche est affichée (c'est-à-dire quand la propriété Visible de la fiche prend la valeur True).

Voici un petit tableau qui donne les caractéristiques importantes des fiches. Ce genre de tableau sera répété pour

chaque composant dans la suite du chapitre. 

Fiche technique

                                                          Icône                        (aucune)

                                                         Visibilité                  Visible.

                                                          Conteneur                Oui

Pour voir la liste des fiches d'un projet, il faut utiliser la commande "Fiches " du menu "Voir" ou le raccourci clavier Shift+F12. Ceci a pour effet de faire apparaître une liste des fiches : 

Pour en faire apparaître une, sélectionnez-la puis cliquez sur OK. 

Voici maintenant une liste des propriétés intéressantes à connaître pour les fiches :  Propriétés

Les deux choix suivants servent à créer des barres d'outils : 

Méthodes

                        Close                 

                        Show                      Montre une fiche. Vous pouvez obtenir le même effet en fixant la propriété Visible à True.

3.           Modales ou non ?

Les fenêtres modales sont une possibilité intéressante de Delphi. Une fenêtre devient modale lorsqu'elle est montrée au moyen de sa méthode ShowModal. On la ferme ensuite au choix en fixant une valeur non nulle à sa propriété

ModalResult, ou en appelant sa méthode Close qui, en fait, affecte la valeur constante "mrCancel" (valeur 2) à

ModalResult. Cette propriété permet de renseigner sur les circonstances de fermeture de la fenêtre, ce qui est souvent très utile. Une fenêtre modale se distingue en outre d'une fenêtre normale par le fait qu'elle doit être refermée avant de pouvoir continuer à utiliser l'application. Une utilisation classique en est faite pour créer des boites de dialogue : ces dernières doivent être refermées avant de pouvoir continuer à travailler dans l'application (prenez la boite de dialogue "A propos de " de Delphi par exemple). 

La propriété ModalResult ferme donc une fiche modale lorsqu'elle est fixée différente de 0. Mais c'est une propriété de type énuméré, c'est-à-dire que ses valeurs sont prises parmi un jeu d'identificateurs ayant des noms significatifs. Pour fermer une fiche en donnant une information sur les circonstances de fermeture de la fiche (OK, annulation, ), on pioche parmi ces valeurs. Voici une liste de valeurs possibles pour ModalResult (la valeur numérique, qui n'a aucune signification, est donnée à titre indicatif entre parenthèses) : 

o    mrNo (7) : signifie que l'utilisateur a répondu par la négative à une question. 

Toutes ces valeurs ne sont bien évidemment pas appropriées dans toutes les situations, elles permettent juste de couvrir un large éventail de circonstances standards de fermeture : souvent seules les valeurs mrOK et mrCancel sont significatives et signifient souvent que l'utilisateur a cliqué sur un bouton "OK" ou "Annuler". 

                B.      Composant "MainMenu"

Fiche technique

Icône

                                                         Visibilité                 Invisible à la création, visible ensuite.

                                                          Conteneur                Non

Ce composant permet de munir la fiche d'une barre de menus déroulants comme vous en utilisez très souvent. Ce composant est non visuel lorsqu'on vient de le poser sur une fiche : au lieu d'un composant visible, l'icône du composant vient se placer sur la fiche. A partir de son pseudo-bouton, vous pouvez accéder via un double-clic à une interface spécifique de création de menus. Cette interface permet de créer directement de façon visuelle les menus en utilisant l'inspecteur d'objets et quelques raccourcis clavier. Cette interface permet en fait d'éditer la propriété "Items" du composant

(en sélectionnant la propriété, puis en cliquant sur le bouton qui permet d'éditer des propriétés complexes, vous accédez à la même chose).

Les propriétés importantes du composant "MainMenu" sont décrites ci-dessous :  Propriétés

                        Images                     Référence à un composant "ImageList".

Permet d'associer à un menu une liste d'images stockées dans un composant "ImageList".

Permet l'accès à l'éditeur de menus.

C.      Composant "TPopupMenu"

Fiche technique

Icône

                                          Visibilité                 Invisible à la création, peut être visible à l'exécution

                                          Conteneur                Non

Ce composant permet de créer un menu contextuel. Les menus contextuels ont ceux qui apparaissent lorsqu'on

clique avec le bouton droit de la souris. Ce genre de menu doit son nom au fait qu'il semble adapté à la zone sur laquelle on clique. En fait, il faut souvent dans la pratique créer plusieurs menus contextuels et les adapter éventuellement (en activant ou désactivant, ou en cachant ou en montrant certains choix) pendant l'exécution de l'application. La création de ce menu se fait dans le même genre d'interface que les menus principaux ("MainMenu"). Propriétés

Y dont la signification varie suivant la valeur de la propriété "Alignment"

D.      Composant "Label"

Fiche technique

Icône

                                          Visibilité                  Visible

                                          Conteneur                Non

Un composant "Label" permet d'inclure facilement du texte sur une fiche. Ce texte n'est pas éditable par

l'utilisateur et c'est donc un composant que l'on utilise souvent comme étiquette pour d'autres contrôles. Bien que l'on puisse modifier la police utilisée pour l'écriture du texte, il faut toujours freiner ses ardeurs. Ces composants sont en général en grand nombre sur les fiches importantes, mais cela ne pose pas de problème car ils ne prennent presque pas de mémoire. 

Un composant "Label" peut contenir jusqu'à 255 caractères, ce qui le limite à des textes très courts. Les propriétés "AutoSize" et "WordWrap" permettent d'obtenir une bande de texte à largeur fixe sur plusieurs lignes, ce qui sert souvent pour donner des  descriptions plus étoffées que de simples étiquettes. Les composants "Label" sont très souvent utilisés et le seront donc dans les manipulations futures. 

Propriétés

                E.      Composant "Edit"

Fiche technique

Icône

                                                         Visibilité                  Visible

                                                          Conteneur                Non

Les composants "Edit" permettent de proposer des zones d'édition. Ces zones très souvent utilisées sous Windows ne contiennent qu'une ligne de texte, dont la police peut être réglée, toujours avec la même parcimonie. Ce composant permet à l'utilisateur d'entrer une information quelconque tapée au clavier. Le texte entré dans le composant est accessible via une propriété "Text". Il est possible de fixer une limite à la longueur du texte entré, de masquer les caractères (utile pour les mots de passe), de désactiver la zone ou d'interdire toute modification du texte.  Propriétés

Conseil : veillez à ne pas écrire de code trop long à exécuter dans la procédure de réponse à cet événement, car il se produit assez souvent lorsqu'un utilisateur remplit un formulaire constitué de quelques zones d'édition par exemple.

F.      Composant "Memo"

Fiche technique

Icône

                                          Visibilité                  Visible

Le composant "Memo" permet l'édition de texte sur plusieurs lignes. Une utilisation célèbre de ce composant est faite par le bloc-notes de Windows. Ce composant ne traite pas la mise en forme des caractères comme dans WordPad (pour cela, un autre composant, "RichEdit", est tout indiqué). Le composant "Memo", placé sur une fiche, permet donc lors de l'exécution, d'écrire du texte, d'ajouter des lignes en appuyant sur Entrée, d'éditer facilement ce texte (les fonctionnalités de copier-coller ne sont cependant pas automatiques et vous devrez apprendre à les programmer, j'essaierai de traiter un exemple d'utilisation du presse-papier dans un futur chapitre, il est encore un peu tôt pour cela). 

Concrètement, un mémo stocke le texte sous formes de lignes : chaque ligne est une chaîne de caractères. La propriété objet "Lines" des composants "Memo" permet l'accès aux lignes du mémo et leur manipulation. L'interface de Delphi permet même d'écrire directement dans le mémo en éditant la propriété "Lines". 

Propriétés

G.     Composant "Button"

Fiche technique

Icône

                                          Visibilité                  Visible

                                          Conteneur                Non

Pas vraiment besoin de présenter longuement ici le composant Button : vous vous en servez depuis un bon moment si vous suivez ce guide depuis le début. Ce composant sert en général à proposer à l'utilisateur une action. Cette action lui est expliquée par un texte très court sur le bouton, du style "OK" ou "Annuler". Lorsque l'utilisateur clique sur le bouton, ou appuie sur Espace ou Entree lorsque celui-ci est sélectionné (ce qui revient à le cliquer), l'événement OnClick se produit, qui offre une possibilité de réaction. C'est en général dans la procédure de réponse à cet événement qu'on effectue l'action proposée à l'utilisateur, comme afficher ou fermer une fiche par exemple pour citer des exemples récents.  

Les boutons ont une fonctionnalité en rapport avec les fenêtres modales : ils ont une propriété ModalResult. Cette

Propriétés

                H.     Composant "CheckBox"

Fiche technique

Icône

                                                          Conteneur                Non

Un composant CheckBox permet de donner à l'utilisateur un choix de type "Oui/Non". S'il coche la case, la réponse est "Oui", sinon, c'est "Non". Au niveau du code, une propriété de type booléen stocke cette réponse : Checked. Il est possible de donner un texte explicatif de la case à cocher dans la propriété Caption. Ce texte apparait à coté de la case. Une modification de l'état de la case déclenche un événement OnClick, que cette modification provienne effectivement d'un clic ou d'une pression sur la touche Espace. La modification depuis le code source de la propriété Checked ne déclenche pas cet événement. 

Propriétés

Caption                    Permet de spécifier le texte qui apparait à coté de la case à cocher. Il est à noter que le composant ne se redimensionne pas pour afficher automatiquement tout le texte. Ce sera donc à vous de prévoir cela si c'est nécessaire.

                        Checked                  Permet de connaître ou de modifier l'état de la case : cochée ou pas.

Événements

                        OnClick                  Déclenché lorsque l'état de la case à cocher change, quelle que soit l'origine du changement.

La propriété Checked est déjà mise à jour lorsque la procédure de réponse à cet événement s'exécute.

XIII. Programmation événementielle et envoi de messages

A.      Définition

On voit ci-dessus que les objets des différents composants (visuels ou non) réagissent lorsqu’une action extérieure intervient : par exemple appuis sur une touche du clavier, déplacement de la souris,  top de l’horloge interne ou toute autre interruption matérielle ou non.

B.      Exemple

Créons une fiche avec 2 boutons appelés (propriété name) respectivement Button1 et Button2 et comportant tous deux la même inscription : « Appuyez ici » (propriété caption). De plus la propriété visible de l’un est à true et de l’autre est false.

On fera un double-clic indique  dans l’inspecteur d’objets l’onglet évènement pour chaque bouton sur l’évènement

OnMouseMove

Le but du programme est de rendre invisible le bouton sur lequel l’utilisateur essaye de cliquer et de rendre l’autre visible :

unit Unit1;   Form1: TForm1;

interfaceimplementation

{$R *.DFM}

uses  Windows, Messages, SysUtils, Classes, 

Graphics, Controls, Forms, Dialogs,StdCtrls, procedure TForm1.Button1MouseMove(Sender:

ComCtrls, ExtDlgs; TObject; Shift: TShiftState; X,

   Y: Integer); typebegin

  TForm1 = class(TForm)   button1.visible := false;

    Button1: TButton;   button2.visible := true

    Button2: TButton; end;     procedure Button1MouseMove(Sender: 

TObject; Shift: TShiftState; X,Y: Integer); procedure TForm1.Button2MouseMove(Sender:     procedure Button2MouseMove(Sender: TObject; Shift: TShiftState; X,

TObject; Shift: TShiftState; X,Y: Integer);   Y: Integer);

privatebegin

{ Déclarations privées }   button2.visible := false;   public button1.visible := true

{ Déclarations publiques }end;

end;   end.  var

C.      Réponse à un événement

Reprenons l’exemple (page 67)de création dynamique d’une forme et d’un bouton et ajoutons-lui une réaction à un click :

program tst_form;     procedure repondre(expediteur : tobject);  end;

uses   Forms, stdctrls, dialogs;   procedure bidon.repondre(expediteur : type bidon=class tobject);

Delphi et Kilix          82           D. Mailliet   begin   maForm.width:=400;

     showmessage ('ok')   maForm.caption := 'nouvelle fiche';

     Parent := maForm; var     top := 20;

  maForm:tform;     left := 20;

  gamelle: bidon;     height := 20; begin     width := 200;

  Application.Initialize;     caption := 'nouveau bouton';

  Application.CreateForm(TForm, maForm);     onclick := gamelle.repondre;

  maForm.visible := true;   end;   :=30; ;   :=100; end.    maForm.height:=300;

La gestion d’un événement se fait par une méthode (et non une simple procédure)  ce qui explique la création d’une classe bidon instanciée par l’objet gamelle . En Réalité, la méthode fait partie de la classe créée spécialement et qui réagit à l’événement qui lui correspond ! 

                D.     Retour sur les fichiers DFM

L’exemple précédent, s’il est correct, n’est pas « propre » : fabriquer une clase bidon pour traiter un événement n’est pas des plus lisible. Il vaut mieux créer une classe englobant la fiche, le bouton et le traitement de l’événement comme suit :

program Project2;

uses

  Forms,  stdctrls,  dialogs;

type TmaForm=class(tform) monbouton : TButton;     procedure repondre(expediteur : tobject);   end;

procedure TmaForm.repondre(expediteur :

tobject);   begin      showmessage ('ok')   end;

var   maForm:TmaForm;

{$R }

begin

  Application.Initialize;

  Application.CreateForm(TmaForm, maForm);   maForm.visible := true;   :=30;   :=100;   maForm.height:=300; maForm.width:=400;   maForm.caption := 'nouvelle fiche';   maForm.monbouton:= TButton.Create(maForm);   with maForm.monbouton dobegin Parent := maForm;     top := 20;     left := 20;     height := 20;     width := 200;     caption := 'nouveau bouton';     onclick := maForm.repondre;   end; ; end.  

On remarquera la présence de {$R } (ou de {$R *.dfm} s’il n’y a pas de confusion possible). Le fichier est un simple fichier texte comportant :

Il contient presque rien, mais il est Obligatoire !ceci est à mettre en relation avec le chapitre sur « Constitution des fichiers

DPR, DMF, PAS » 

                E.      Exemple pratique : bouton à double fonctionnalité

Le but est de du programme est de changer la fonctionnalité d’un bouton : par exemple, on souhaite mettre à jour une liste quelconque et l’on dispose d’un bouton intitulé (caption) ajouter sur lequel on peut cliquer. Le même bouton permet de valider la mise à jour son intitulé se transformant en valider. Bien entendu à chaque intitulé, correspond une fonctionnalité différente entraînant un traitement différent. Entre autre, 3 solutions s’offrent à nous :

1.             1 Bouton £1 évènement 

Dans l’exemple qui suit, on a un bouton, et l’on teste son intitulé : Attention, il faut faire attention à la chasse (Majuscule / Minuscule) des captions. Selon son titre, le traitement s’effectue selon le cas 1 ou 2.

unit Unit1;   implementationinterface

{$R *.dfm}

uses

  Windows, Messages, SysUtils, Variants, Classes, procedure TForm1.Button1Click(Sender:

Graphics, Controls, Forms, TObject);

  Dialogs, StdCtrls; begin

typewith button1 dobegin

  TForm1 = class(TForm)     if caption='Ajouter' thenbegin     Button1: TButton;       caption:='Valider'; 

procedure Button1Click(Sender: TObject);   //traitement cas 1  

privateendelsebegin

{ Déclarations privées }       caption:= 'Ajouter';

public//traitement cas 2

{ Déclarations publiques }end;

end;   end;

end; varend.

  Form1: TForm1;

Il n’y a qu’un seul bouton, l’utilisateur ne voit qu’un bouton dont l’intitulé change et qui réagit en conséquence.

2.             2 Boutons £2 évènements 

Ici, on utilise 2 boutons que l’on cache (propriété visible) alternativement.

unit Unit1;   {$R *.dfm}  

uses TObject);

  Windows, Messages, SysUtils, Variants, Classes, begin

Graphics, Controls, Forms,   button2.Width:=button1.Width; Dialogs, StdCtrls;   ;    ; type button2.Height:=button1.Height;

  TForm1 = class(TForm)   button2.Visible:=false;

    Button1: TButton; end;     Button2: TButton; 

procedure Button1Click(Sender: TObject); procedure TForm1.Button1Click(Sender:     procedure FormCreate(Sender: TObject); TObject);     procedure Button2Click(Sender: TObject); begin

private   button2.Visible:=True;

{ Déclarations privées }   button1.Visible:=false;   public//traitement cas 1

{ Déclarations publiques }end;

end;   procedure TForm1.Button2Click(Sender:

var TObject);

  Form1: TForm1; begin button1.Visible:=True; implementation   button2.Visible:=false;   //traitement cas 2end; end.

L’utilisateur à toujours l’impression de ne voir qu’un seul bouton, car le programmeur, qui a placé le second n’importe où sur la fiche, a pris soin dans l’évènement FormCreate de donner au button2 les mêmes caractéristiques que button1. Et donc l’utilisateur le voit apparaître au même endroit et croit que c’est le même bouton dont seul le titre a changé.

L’avantage de cette deuxième solution est d’éviter de faire un test pour savoir dans quel cas l’on se trouve. L’inconvénient est d’avoir un objet (bouton) supplémentaire. 

                3.            1 Bouton £2 événements

Dans cette troisième solution, on ne manipule qu’un seul bouton, mais chaque click entraîne un changement de gestionnaire d’évènement OnClick  du button1

unit Unit1;   {$R *.dfm}

interfaceprocedure TForm1.Button1Click1(Sender:

uses TObject);

  Windows, Messages, SysUtils, Variants, Classes, begin

Graphics, Controls, Forms,  with button1 dobegin Dialogs, StdCtrls;    OnClick:=Button1Click2;

    caption:= 'Valider';

typeend;

    Button1: TButton; end;

procedure Button1Click1(Sender: TObject);      procedure Button1Click2(Sender: TObject); procedure TForm1.Button1Click2(Sender: private TObject);

{ Déclarations privées }begin

publicwith button1 dobegin

{ Déclarations publiques }    OnClick:=Button1Click1;

end;    caption:= 'Ajouter';

end;

var//traitement cas 2

  Form1: TForm1; end;

implementationend.

                4.            Conclusion

Les 3 solutions se valent, seules les techniques diffèrent. La première est la plus compacte, mais souffre de 2 inconvénients dus au if : 

                       -      Les 2 traitements sont dans la même méthode     séparation des taches moins évidente donc lisibilité moindre.

Le test sur les caption doit absolument respecter la chasse des caractères : par exemple si la caption vaut ‘Valider’ et que le test se fait sur ‘valider’, celui-ci vaudra false !.

XIV. Événements et Envoi de messages

Un événement est une action ou une occurrence détectée par un programme. La plupart des applications modernes sont dites pilotées par événements, car elles sont conçues pour répondre à des événements. Dans un programme, le programmeur n’a aucun moyen de prévoir la séquence exacte des actions que va entreprendre l’utilisateur. Il peut choisir un élément de menu, cliquer sur un bouton ou sélectionner du texte. Vous allez donc écrire le code qui gère chacun des événements qui vous intéressent au lieu d’écrire du code s’exécutant toujours selon le même ordre.

                A.      Evénements utilisateur

Les événements utilisateur sont des actions initiées par l’utilisateur. Les événements utilisateur sont, par exemple, OnClick

B.      Evénements système

Ce sont des événements que le système d’exploitation déclenche pour vous. Par exemple, l’événement OnTimer (le composant Timer déclenche l’un de ces événements lorsqu’un intervalle prédéfini s’est écoulé), l’événement OnCreate (le composant est en train d’être créé), l’événement OnPaint (un composant ou une fenêtre a besoin d’être redessiné), etc. En règle générale, ces événements ne sont pas directement déclenchés par des actions de l’utilisateur..

Toutes les classes Delphi disposent d’un mécanisme intégré pour gérer les messages : ce sont les méthodes de gestion des messages ou gestionnaires de messages.

L’idée sous-jacente aux gestionnaires de messages est la suivante : un objet reçoit des messages qu’il répartit selon le message en appelant une méthode choisie dans un ensemble de méthodes spécifiques. Un gestionnaire par défaut est appelé si aucune méthode n’est définie pour le message.

Le diagramme suivant illustre le fonctionnement du système de répartition de message :

Evénement    MainWndProc    WndProc     Dispatch    Gestionnaire

Exemple 1

La procedure AppMessage définie ci-dessous capture tous les évènements OnMessage de l'application. Attention cette procédure est appelée pour chaque message si vous  n'y prenez garde, elle peut ralentir votre application les messages arrivent même s'ils sont destinés à une autre fenêtre que la fenêtre principale (essayez dans la fenêtre du ShowMessage) }

…

Type

  TForm1 = class(TForm)

procedure FormCreate(Sender: TObject);   private

procedure AppMessage(var Msg: TMsg; var Handled: Boolean);   end;

Var   Form1: TForm1; implementation

{$R *.DFM}procedure TForm1.FormCreate(Sender: TObject);

{-----------------------------------------------------

affectation de AppMessage en temps que procédure déclenchée par OnMessage

begin

  Application.OnMessage := AppMessage; end;

procedure TForm1.AppMessage(var Msg: TMsg;  var Handled: Boolean);

{ procédure lancée par chaque événement

Affectez la valeur True à Handled si le message a été complètement  géré afin d'empêcher le traitement normal du message. }begin

if (Msg.message =WM_KEYDOWN) then

      ShowMessage('message WM_KEYDOWN  dans AppMessage')    else

if (Msg.message =WM_RBUTTONDOWN) then

ShowMessage('message WM_RBUTTONDOWN dans AppMessage'); { handled=true; aurait empéché la suite du traitement normal du message:

il n'aurait donc pas été traité par WindProc}end;

Déclaration d’une méthode spécifique pour le traitement du messageu envoyé lors d’un click droit sur la souris Type

  TForm1 = class(TForm)

    Panel1: TPanel;

private

procedure SourisCliqueDroit( var msg:TMessage); message WM_RBUTTONDOWN; end;

Var   Form1: TForm1; implementation

{$R *.DFM}

procedure TForm1.SourisCliqueDroit( var msg:TMessage); begin

  ShowMessage('Message détecté dans SourisCliqueDroit');   inherited; // si on veut continuer à propager le messageend;

Le message est envoyé par la Tform1 et non par les objets qui lui appartiennent  Un clic droit dans le panel1 n’en envoie pas !

…

Const

WM_MESSAGEPERSO = WM_USER + 1; 

{ le 1 peut être remplacé par le nombre de votre choix  ne pas utiliser le même nombre  pour un autre message }type

  TForm1 = class(TForm)     Button1: TButton;

procedure Button1Click(Sender: TObject);   private

procedure WMMessagePerso(var Msg : TMessage);   message WM_MESSAGEPERSO; 

// procédure destinée à recevoir notre messageend;

Var   Form1: TForm1; implementation{$R *.DFM}

procedure TForm1.Button1Click(Sender: TObject); begin

SendMessage(Form1.Handle,          WM_MESSAGEPERSO,0,0);

//envoi de notre message à  Form1end;

procedure TForm1.WMMessagePerso(var Msg : TMessage); begin

end;

Sur une forme, un bouton et un panel procedure TForm1.Button1Click(Sender: TObject);

begin

       Panel1.Color:=clRed;

       sleep(3000);                  // delays 3000 msec

       Panel1.Color:=clGreen; end;

procedure TForm1.Button1Click(Sender: TObject);

begin

       Panel1.Color:=clRed;

       Application.ProcessMessages;

On pourrait espérer que le clic sur le bouton entraîne une coloration rouge du panel pendant 3 secondes et qu’ensuite, il devienne vert.

Il n’en est rien car la méthode repaint ne sera appelée qu’en sortie de procédure : le message envoyé est capturé et traité par cette procédure qui ne rend la main que lorsqu’elle a fini.

Et donc le vert vient recouvrir immédiatement le rouge que l’œil n’a pas le temps de percevoir

La solution consiste àlaisser passer les messages

       sleep(3000); // delays 3000 msec

       Panel1.Color:=clGreen;

End

XV. Exemple récapitulatif

Il s’agit de réaliser un programme simulant une calculatrice conforme aux spécifications du TP2, mais il ne s ‘agit pas d’un corrigé dans la mesure ou le cours n’était pas suffisemment avancé pour fournir une réponse de cette nature .

unit Unit1;

interface

uses

  Windows, Messages, SysUtils, Variants, Classes,

Graphics, QControls, Forms,

  Dialogs, StdCtrls, ExtCtrls, Controls;

type      tbbout = classprivate         nl,nc :byte;         proprio:tcomponent;       public

        tb : arrayofarrayof TButton;

constructor create(nl,nc:byte;proprio:tcomponent;tt:TNotifyEvent; kp:TKeyPressEvent);         procedure dimensionne;       end;

  Calculatrice = classprivate

       Op1,Op2 : Extended;//Operandes de l'entree en cours

       Operation : char;//stocke l'operation demandée parmi {+,-,/,*} entree_en_cours : string;        nbop:byte;       public

Function Gere_chif(Chaine:string) : string;

Function Gere_oper(Chaine:string) : string;

Procedure Clear;//Efface tous les champs après operation

Function ExecOperation : Extended;       end;

  TForm1 = class(TForm)

    Button_egal: TButton;

    Panel_chif: TPanel;     Panel_oper: TPanel; Button_clear: TButton;     afficheur: TLabel;

procedure FormCreate(Sender: TObject);

procedure FormClose(Sender: TObject; var Action: TCloseAction);

procedure FormResize(Sender: TObject);     procedure Button_egal_Click(Sender: TObject);     procedure Button_clear_Click(Sender: TObject);     procedure FormKeyPress(Sender: TObject; var Key: Char);   private

    Calculette:Calculatrice;     boutons_oper,boutons_chif : tbbout;     old_width : integer;

procedure traite_chif(Sender: TObject);     procedure traite_oper(Sender: TObject);   end;

var

  Form1: TForm1;

Implementation{$R *.dfm}

const MINI=378;

{--------------------- classe calculatrice -----------------------------}

constructor Calculatrice.create; begin

inherited;   clear;   nbop:=0;

end;

procedure Calculatrice.Clear;

begin   Op1:=0;

  Op2:=0;   Operation:=#0;   entree_en_cours:='';

end;

function Calculatrice.Gere_oper(chaine:string):string ; begin inc(nbop);

if entree_en_cours='' then  entree_en_cours:= '0';   case nbop of

  2 :  op1:=ExecOperation;

  1 : Op1:=StrtoFloat(entree_en_cours);   else op1:=0;   end;

  Operation:=Chaine[1];   result:=FloatToStr(op1); entree_en_cours:=''; end;

Function Calculatrice.Gere_chif(chaine:string) : string; begin

if chaine=',' thenbegin

if entree_en_cours='' then entree_en_cours:='0,';     result:=entree_en_cours;     if ansipos(',',entree_en_cours) <> 0 then Exit;//éviter de mettre 2 virgules!end;

if chaine='+/-'  thenbegin// il faut juste prendre l'opposé

if (entree_en_cours<>'') then

if entree_en_cours='0' then entree_en_cours:=Chaine     else

      entree_en_cours:=entree_en_cours+Chaine; result:=entree_en_cours; end;

function Calculatrice.ExecOperation: Extended; begin

   op2:=StrtoFloat(entree_en_cours);    if nbop>0 then dec(nbop);

Case Operation of

          '+' : Result:=Op1+Op2;

          '-' : Result:=Op1-Op2;

          '*' : Result:=Op1*Op2;

          '/' : begin

if op2=0 then Exit;                 Result:=Op1/Op2;

end;            else result:=0;     end;

  entree_en_cours:=floatToStr(result);

  Operation:=#0; end;

{--------------------- classe tbbout -----------------------------}

constructor tbbout.create(nl,nc:byte;proprio:tcomponent;tt:TNotifyEvent;kp:TKeyPressEvent); var i,j:byte; begininherited create;   :=nl; :=nc;   self.proprio:=proprio;   setlength(tb,nl,nc);   for i:= 0 to nl-1 dofor j:=0 to nc-1 dobegin tb[i,j]:= TButton.create(proprio);       with tb[i,j] dobegin

        parent:= proprio as TWinControl;         caption := intTostr(i*nc+j+1); Font.Charset := DEFAULT_CHARSET;

        Font.Color := clWindowText ;

        Font.Height := -24 ;

        Font.Name := 'MS Sans Serif' ;         Font.Style := [fsBold]  ;         onclick := tt;         onkeypress:=kp;       end; end;

end;

procedure tbbout.dimensionne;

var i,j:byte; w,h,l,t : integer; begin

  w:=((proprio as TWinControl).width-30) div nc -20;

  h:=((proprio as TWinControl).height-30) div nl -20;   t:=-h;

for i:= 0 to nl-1 dobegin t:=t+h+20;     l:=-w;

for j:=0 to nc-1 dobegin l:=l+w+20;       tb[i,j].width:=w;       tb[i,j].height:=h; tb[i,j].top:=t;       tb[i,j].left:=l;     end;   end; end;

{--------------------- classe Tform1 -----------------------------}

procedure TForm1.FormResize(Sender: TObject); begin width:=height;

    self.ChangeScale(width,old_width);     old_width:=width; end;

procedure TForm1.FormCreate(Sender: TObject); begin

  calculette:=Calculatrice.Create;

Panel_oper.BevelInner := bvNone;  Panel_oper.BevelOuter := bvNone; Panel_chif.BevelInner := bvNone;  Panel_chif.BevelOuter := bvNone; boutons_chif := tbbout.create(4,3,panel_chif, traite_chif,FormKeyPress); boutons_oper := tbbout.create(4,1,panel_oper,traite_oper,FormKeyPress); [3,0].caption:=',';   [3,1].caption:='0'; [3,2].caption:='+/-';   [0,0].caption:='+'; [1,0].caption:='-';   [2,0].caption:='*';   [3,0].caption:='/'; boutons_chif.dimensionne;   boutons_oper.dimensionne; self.Constraints.MinHeight := MINI;   self.Constraints.MinWidth  := MINI; old_width:=width;   calculette.Clear;   afficheur.caption:='0'; end;

procedure TForm1.traite_oper(Sender: TObject); begin

   afficheur.caption:=calculette.Gere_oper(string((Sender as TButton).Caption));    Button_egal.SetFocus;

end;

procedure TForm1.traite_chif(Sender: TObject); begin

   afficheur.caption:=calculette.Gere_chif(string((Sender as TButton).Caption));

   Button_egal.SetFocus; end;

procedure TForm1.Button_egal_Click(Sender: TObject); begin

  afficheur.caption:=floatToStr(calculette.ExecOperation); end;

procedure TForm1.Button_clear_Click(Sender: TObject); begin

  calculette.Clear;   afficheur.caption:='0'; Button_egal.SetFocus; end;

procedure TForm1.FormKeyPress(Sender: TObject; var Key: Char); begin

if key='.' then key:=',';    case upcase(key) of

     '=' :  afficheur.caption:=floatToStr(calculette.ExecOperation);

     'C' :  Button_clear_Click(Sender);

     '0'..'9',',': afficheur.caption:=calculette.Gere_chif(key);      '+','-','*','/': afficheur.caption:=calculette.Gere_oper(key);    end; 

   Button_egal.SetFocus; end;

end.

l’événement :

unit Unit1; interface

uses

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

ComCtrls, ExtDlgs;

type   TForm1 = class(TForm)

    Button1: TButton;

    Button2: TButton;

procedure ButtonMouseMove(Sender:

TObject; Shift: TShiftState; X, Y: Integer);   private{ Déclarations privées }public

{ Déclarations publiques }end;

var   Form1: TForm1;

implementation