Cours introduction à l’emploi du DELPHI, tutoriel & guide de travaux pratiques en pdf.

L’environnement DELPHI

Au lancement du logiciel l’écran a l’aspect ci dessous.
La partie supérieure de l’écran donne accès au système de menus et à la barre d’outils.
Sur la première ligne :
Fichiers permet d’ouvrir un nouveau fichier, un nouveau projet, d’enregistrer votre travail et d’imprimer.
Edition donne accès aux fonctions copier coller classiques ainsi qu’a des outils de présentation.
Exécuter permet de lancer l’exécution d’un programme
La feuille de travail présente à l’écran est le rectangle situé à droite, sous
Delphi on parle de FICHE , un projet peut comporter plusieurs FICHES de ce type ,
Au départ la fiche présentée à l’écran porte le nom initial Form1 .
Cette fiche masque en fait une fenêtre dans laquelle s’écrira le programme source , c’est la fenêtre UNIT que l’on peut visualiser en déplaçant la FICHE avec la souris puis en cliquant dessus , mais nous y reviendrons.
Sur la fiche le programmeur va placer différentes fenêtres secondaires permettant la saisie de données , l’affichage de résultats, des boutons sur lesquels on viendra cliquer avec la souris et peut être aussi des textes et dessins. Toutes ces choses sont des OBJETS.
Il y a de nombreux objets définis dans DELPHI , l’utilisateur confirmé peut même en écrire d’autres , mais c’est une autre histoire ! Ces objets sont graphiques ou non .
Chaque objet possède un certain nombre de caractéristiques ( taille couleur format du texte etc…) et peut effectuer diverses tâches qui caractérisent le type auquel il appartient.
En PASCAL classique on trouve la notion de type pour définir les éléments qui constituent un programme, type booléen, caractère, chaîne etc…Cette notion de type se retrouve dans DELPHI mais en beaucoup plus complexe. Pour manipuler un objet qui apparaît dans un écran sous Windows il est nécessaire d’écrire de nombreuses lignes de code, elles définissent le type de base TObjet à partir duquel sont construits tous les autres en ajoutant à chaque fois une couche logicielle supplémentaire. Cette structure hiérarchisée est une caractéristique essentielle des langages objet L’Objet button par exemple est de type Tbutton qui est un descendant de Tobjet , il en est de même de Tform .
Pour accéder à ces objets regardons la seconde ligne de l’écran .En cliquant sur le premier bouton Standard nous voyons apparaître une première liste
Parmi tous ces objets nous retiendrons surtout
A Définit à l’écran une zone dans lequel on peut écrire une ligne de texte
.Reconnu dans DELPHI sous le nom de Label de type Tlabel.
ab est une zone de saisie , c’est dans cette fenêtre que nous introduirons les données demandées par le programme nombres ou caractères. Reconnu dans DELPHI sous le nom de Edit de type TEdit ok est un bouton de commande sur lequel il faudra cliquer avec la souris , sous DELPHI Button de type Tbutton .
Nous utiliserons surtout ces 3 outils . Les boutons supplémentaires de la seconde ligne:
Supplément Win32 Système etc donnent accès à d’autres objets , nous en rencontrerons quelques uns par la suite .
Chaque objet possède des propriétés qui lui sont propres , taille , fonte utilisée pour le texte, nature du texte , nom etc.. Ces propriétés apparaissent dans la partie gauche de l’écran . l’inspecteur d’objets lorsque l’objet est sélectionné.
Nous citerons
Caption ( en français légende ) c’est le texte qui apparaît dans l’objet considéré
Name c’est le nom de l’objet utilisé par le logiciel , ne pas le confondre avec le précédent.

Color la couleur

Font : qui permet de choisir la fonte utilisée pour les caractères , taille et couleur.
On peut noter encore AutoSize ( True ou False) qui gère l’ajustage automatique de la fenêtre à celle du texte Caption. , Visible ( True ou False) qui définit la visibilité à l’écran de l’objet considéré, on peut ainsi masquer des fenêtres pour ne faire apparaître qu’une seule à un moment donné.
La colonne evenements permet pour chaque objet de définir des circonstances le concernant, par exemple pour un bouton le déclenchement s’effectuera à l’enfoncement du bouton ( Onclick) ou son relâchement .
Ci contre l’inspecteur d’objets correspondant à la fiche Form1 elle même , noter Caption=Form1 c’est le nom de la fiche Color=ClbTnFace ( un gris) , sa hauteur Height=563 etc…

Premier PROJET

La construction d’un projet comporte deux étapes essentielles, la mise en place de la présentation à l’écran puis l’écriture du logiciel PASCAL associé à tous les objets.
Notre premier projet est très simple mais illustre bien le mécanisme de DELPHI . Nous nous proposons d’écrire un programme d’extraction de racine carrée de nombres entiers.
.L’écran sous Windows sera constitué de deux zones de texte et d’un bouton. La première est la zone de saisie dans laquelle nous allons entrer un nombre entier Dans la seconde apparaît le résultat obtenu en cliquant sur le bouton . Ces trois objets sont placés sur un fond vert.
Si l’écran d’entrée n’est pas celui décrit plus haut y revenir par Fichier ⇒ Nouveau une fenêtre s’ouvre, sélectionner ⇒application
La première chose à faire est de définir les noms des fichiers constituant le projet, le non du projet lui même et celui de la fiche et programme pascal.
Pour cela effectuons un premier sauvetage de sécurité par :
Fichier ⇒Tout Enregistrer.
Une fenêtre s’ouvre qui nous demande d’abord le nom de l’unité ,c’est à dire du programme PASCAL, par défaut unit1 , choisissons premier , il faut ensuite entrer le nom du projet , par défaut Project1 que nous changeons en Projet 1
Dans le répertoire Projet plusieurs fichiers sont crès , ils constituent l’ensemble des fichiers nécessaires pour la compilation du projet .
Nous allons maintenant construire l’aspect graphique du projet.
Revenons à la fiche dont le nom est toujours Form1. Sur l’Inspecteur d’objets nous modifierons la couleur en cliquant à droite sur la ligne Color , une liste déroutante apparaît, choisissons le vert qui a pour nom clLime . En revenant sur la fiche est devient verte.
Nous allons ensuite écrire le titre Mon premier programme dans un objet qui est une zone de texte , l’objet A vu plus haut. Dans la ligne des objets cliquons sur A , qui est alors activé (il apparaît dans un carré plus clair) , puis au centre de la fiche ou s’inscrit le mot label1 ( nom par défaut ) (entouré de petits carrés noirs, les poignées de réglage , indiquant que l’objet est activé.) Dans la fenêtre de gauche apparaissent les propriétés de cet objet.
La ligne Name = Label1 c’est le nom par défaut que nous ne modifierons pas ( mais c’est possible) la ligne Caption présente le même nom , c’est lui qui est visible à l’écran nous y introduirons le titre choisi Mon premier programme.
Les lettres sont toutes petites , en cliquant sur la ligne Font une fenêtre s’ouvre permettant de choisir le type de caractères, par exemple ARIAL , la taille , par exemple 24 , la couleur (conservons le noir). Nous ne modifierons pas la propriété Color pour que la fenêtre aie la même couleur que le fond .. .
Il est possible de déplacer le titre à la souris pour l’amener à l’emplacement le meilleur.
.L’écran est alors représenté ci contre.
Maintenant plaçons la fenêtre dans laquelle nous écrirons le nombre entier dont nous voulons calculer la racine carrée. C’est un objet de saisie ab désigné par Delphi comme Edit . Cliquons donc sur ab dans la ligne des objets pour l’activer et le placer ensuite sur la fiche à gauche en dessous du titre . Un rectangle blanc apparaît avec le titre Edit1 . Dans la fenêtre de gauche définissons ses propriétés .
Sa couleur Color= (clYellow) Jaune, il ne faut pas modifier son nom (Name) mais effacer le texte en changeant caption= ‘ ‘ ( en pressant sur la barre d’espace) Choisir ensuite la taille et fonte des caractères dans Font ( Arial 14, noir)
Si la propriété AutoSize est vraie (true) la taille de la fenêtre de saisie s’ajustera automatiquement à celle du nombre que l’on écrit. Pour la conserver de taille fixe ( ajustée à la souris) il vaut mieux choisir AutoSize=False (fausse)
Au départ du programme cette fenêtre sera vierge de tout nombre, pour guider l’utilisateur nous allons lui associer une étiquette Entrer entier . Dans une petite fenêtre (objet A) placée juste au dessus. Pour cela la procédure est la même que celle qui nous a permis de placer le titre , l’objet A introduit prend automatiquement le nom label2
Le résultat du calcul sera présenté dans un troisième objet A ( label 3) pour lequel nous fixerons la couleur bleue color = clAqua puis la fonte des caractères (arial 14 noirs) .Le mot label3 qui est placé par défaut sera comme précédemment effacer dans caption , attention ne pas toucher à Name. .Cette fois il vaut mieux que le largeur de la fenêtre soit ajustée automatiquement à la taille du résultat nous ferons donc AutoSize=True ;
. Comme plus haut pour guider l’utilisateur plaçons une étiquette racine au dessus de l’objet précédent (label4)
Pour finir il nous faut un bouton sur lequel appuyer pour lancer le calcul. C’est un objet Button que nous irons chercher dans la ligne des objets et placerons sur la fiche entre les fenêtres précédentes. Ce bouton n’a pas de couleur mais changeons caption = calcul Comme d’habitude position et taille peuvent être ajustés avec la souris.
La fiche écran Form1 a maintenant l’allure ci dessus .
Seconde partie du travail écrire le programme PASCAL accompagnant les objets et leurs fonctions. Mais avant examinons la fenêtre du second plan UNIT 1 en cliquant dessus (si elle est en partie visible ou Projets⇒Voir⇒Unites ⇒premier)
Il s’agit d’une routine de type unit avec son nom premier choisi au début .
Dans le listing présenté deux mots ont un rôle essentiel : interface et implementation. Ils définissent deux zones , la première entre ces deux mots , la seconde entre la directive de compilation {$R *.dmp} et le mot fin.
La première zone est descriptive, on trouve d’abord le terme uses suivi de la liste des unités utilisées par le programme PASCAL , cette ligne est la même que dans un programme PASCAL sous DOS. Puis Type ou sont annoncés les types des différents objets introduits dans la construction de l’écran. 4 Labels 1 Edit 1
Button.,puis les variables var ici Form1:Tform indiquant que l’objet Form1 (la fiche principale) est de type Tform.
Derrière les mots Private et Public il est possible de définir des variables . Celles définies dans private ne seront accessibles que par les procédures ou fonctions appartenant à la fiche Form1 , celles dans public sont accessibles pour toutes les fiches d’un programme s’il en comporte plusieurs , par contre elles ne sont pas reconnues dans des procédures indépendantes ( dont le nom ne commence pas par TFOrm1. (voir ci dessous ) .
Exemple :
Soit l’unité suivante, la fiche s’appelle Tform1
( ne figurent ici que les parties concernées par le problème).
Private
A :integer ;
Implementation
{$R*.dfm}
Var
C :integer ;
Procedure Agmente (b:integer);
Begin;
A:=4;
B:=B+1;
C:=3;
End;
Procedure Tform1.FormCreate(Sender:Tobject); Begin
C :=C+1 ;
A :=56 ;
Augmente (A);
End;
La variable A est définie dans Private donc dans Tform1, elle est reconnue par la procédure Tform1.FormCreate mais non dans la procédure Augmente et le compilateur annonce une erreur (ligne en rouge qu’il faudra supprimer ). Par contre C est une variable totalement globale elle est connue aussi bien d’une procédure que de l’autre. Tant qu’a B elle est interne à la procédure Augmente et ne sert que d’intermédiaire, la dernière ligne Augmente (A) envoie 56+1 dans A.
Dernière remarque :
La procédure Sauve utilisée par Tform1 doit être définie avant cette dernière .
Revenons à notre programme :
Dans la seconde zone avant le end final il n’y a rien pour le moment il faut y introduire les informations sur le rôle du bouton. Dans la fiche cliquons donc sur le bouton .Il apparaît alors à l’écran la partie de l’unité concernant ce composant.
Il s’agit d’une procedure ayant pour nom Tform1.Button1Click(Sender :Tobjet) ;
Tform1 pour indiquer que l’on est dans la fiche portant ce nom (la seule du programme dans le cas présent)
Button1Click car l’événement est un click sur le bouton de nom button1 . Entre parenthèse est indiqué que cet objet est un descendant du type de base Tobject.
Lorsque l’on presse le bouton (c’est l’événement déclenchant) le nombre entier qui a été placé dans Edit1 doit être lu , sa racine carrée calculée et le résultat basculé dans la fenêtre de sortie Label3.
Soit :
Par exemple :
Procedure Tform1.Button1Click(Sender :Tobject) ;
Var:a :integer ; // définition d’un entier a
Var b :real ; / // définition d’un réel car la racine est un réel
Begin
a := StrToInt(Edit1.text) ; { le nombre a est le terme Text de l’objet
Edit1, mais il s’agit d’une chaîne de caractères car un Edit ne peut recevoir que
des caractères, la fonction StrToInt ( lire Str To Int) transforme la chaine de
caractères en un nombre entier. }
b :=sqrt(a) ; { extraction de la racine , si l’opération demandée était
plus complexe il faudrait utiliser ici une fonction ou procédure écrite spécialement }
Label3.Caption :=FloatToStr(b) ; { b est un réel (flottant) , que la
fonction Float To Str transforme en chaîne de caractères compatible avec l’objet Label }
End ;
Si on examine maintenant l’unité complète on pourra constater qu’une ligne supplémentaire à été insérée dans la première zone
Procedure Button1Click(Sender :Tobject) ;
Il s’agit de l’annonce dans cette première zone de la procédure qui est écrite dans la seconde. C’est nécessaire si le programme ne le fait pas automatiquement le programmeur devra le faire lui même.