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

Aller au Téléchargement

(3) Créer une fenêtre fille .190 (4) Choisir la création automatique ou non des fiches 190

TP 12 : Créer un composant .193

Créer un nouveau composant ..193 2. Déclaration 193 a) Evénements existants ..193

b)  Evénement ajoutés ..194

c)  Propriétés existantes 194

d)  Propriétés ajoutées ..194

Implémentation ..195 4. Gérer son affichage .198 a) Déclaration .198

b) Implémentation ..199

Gérer les clics .201 a) Déclaration .201

b) Implémentation ..202

Delphi et  KyliX : des descendants de Pascal 

EDI : l’environnement de développement intégré

L’EDI est constitué de 4 fenêtres (seulement les 2 premières pour des applications consoles) .

  La fenêtre principale

Cette partie est elle-même divisée en trois parties :

  La barre de menus

 ("File Edit Search "),  

- Les menus : il n'y a pas grand chose à en dire. Je ne vais pas tous les passer en revue, les noms sont en général bien explicite et il y a l'aide si vraiment il y a peu de chose qui sert dans un premier temps. A part "New Application", "Run" (la flèche jaune en icône) et "Program Reset" pour arrêter l'exécution d'un programme qui ne marche pas, c'est à peu près tout  

  La barre d’outils

Des boutons permettent d’accéder aux commandes les plus fréquemment utilisées.

  La palette de composants

Les composants sont des bouts de programme qui ont déjà été fait pour vous. Exemple Si vous voulez mettre un bouton dans une fenêtre, vous avez juste à prendre un bouton, et le poser sur votre fenêtre sans avoir besoin d'expliquer à l'ordinateur ce qu'est un bouton, comment on clique dessus, ce qu'il se passe graphiquement quand on clique dessus, bref, c'est déjà fait. 

Les plus couramment utilisés sont ceux de la palette de composants "Standard" : dans l'ordre, on peut y voir un menu déroulant, une liste, un label (de l'écriture, quoi ), une ligne d'édition ("edit box"), une zone de texte ("menu"), un bouton, une case à cocher, etc Tout les composants de base d'une fenêtre classique.  Il existe des tonnes de composants, et ils sont souvent compatibles entre Delphi et C++ Builder. Vous en trouverez beaucoup de gratuit sur

Internet, et après, vous les ferez vousmême! Une adresse utile pour trouver de nouveaux composants :  

  L’éditeur de code

Il écrit directement le minimum requis pour votre application et crée seul les fichiers associés. Par contre, le revers de la médaille, il n'est pas conseillé de modifier ce qu'il écrit. Si vous voulez supprimer un bouton par

Delphi et Kilix

exemple, ne l'effacez pas directement dans le code, mais effacez-le graphiquement : le compilateur s'occupera du reste.  Nous verrons plus tard comment rajouter son programme  

  Le concepteur de fiches (ou de « forms »)

C'est la fenêtre que va voir l'utilisateur lorsqu'il lance le programme. Pour l'instant, elle est vide, mais c'est là qu'on peut rajouter les menus, les boutons et tout le reste Vous pouvez, bien entendu, l'agrandir, la réduire, bref, faire tout ce que vous voulez sans taper une ligne de code  

  L’inspecteur d’objets

C'est dans cette partie qu'on donne les caractéristiques des composants que l'on place sur sa fenêtre ou les caractéristiques de la fenêtre générale.  Ici, on peut voir qu'il s'agit des caractéristiques générales de la fenêtre car on voit "Form1: TForm1". "Form1" signifie qu'on regarde les caractéristiques d'un composant de la fenêtre "Form1" (il peut en effet y avoir Form2, Form3, ou même canard ou poisson, puisque vous donnez le nom que vous voulez à chaque fenêtre ) et "TForm1" désigne la fenêtre en général.  Même s'il est possible de changer le nom des composants ou des fenêtres, je vous conseille de laisser les noms par défaut si vous n'avez pas l'intention de faire un programme énorme avec 15 fenêtres différentes. 

Remarque : quand je parle de nom de la fenêtre, ne confondez pas avec ce qu'il y aura d'écrit comme titre de fenêtre. Je parle du nom de la fenêtre pour le programme ("name" dans les "properties") et non pas du titre qui s'affiche à l'écran ("caption" dans les "properties"). Ainsi, si vous placez un bouton sur votre fenêtre, vous changerez ce qu'il y a d'écrit sur le bouton en changeant le "Button1" de

"caption" par

"quitter" ou "enregistrer" ou ce que vous voulez, mais le bouton s'appellera toujours "Button1" pour le

programme,

seul l'affichage changera lors de l'exécution Essayez de changer "caption" (la partie sélectionnée sur l'image) : le nom de la fenêtre change  

  L’aide Delphi

Il ne faut pas hésiter à consulter l’aide Delphi pour obtenir tous les compléments nécessaires : en particulier les fonctions ne sont que décrites et on ne donne pas la liste des paramètres à employer, car ceci son décrits dans l’aide en utilisant la touche F1 ou l’index ou rechercher .

1.   Présentation générale
2.   Structure d’un programme Pascal, Delphi ou Kylix

Cette structure ressemble fort à celle des programmes des langages de haut niveau tels : ADA, C++,Visual basic, Java …

Le programme

Program ;

Uses ;

Déclaration des objets et des outils du programme

<Déclaration des constantes>

<Déclaration des types>

<Déclaration des variables>

Déclaration des procédures

Procedure ( ) ;

Déclaration des objets et des outils de la procédure

< Structure identique à la déclaration des objets et des outils

du programme >

Begin

Corps de la procédure

End ;…

Déclaration des autres  procédures et des autres fonctions

< Identique à la structure ci-dessus et ci-dessous>…

Déclaration des fonctions

Function() : ;

Déclaration des objets et des outils

< Structure identique à la déclaration des objets et des outils du programme >

Begin

Corps de la fonction result :=   End ;

BEGIN

Corps du programme

END .

Le nom du programme doit être le même que le nom du fichier qui le contient.

Ces parties encadrées sont facultatives

Il n’est pas impératif de respecter l’ordre indiqué ci-contre

Remarquons

que la structure des déclarations des outils et des objets (cadres doubles) est identique à la structure qui les contient : un peu à la manière des « poupées russes » qui s’ouvrent en 2 parties et qui contiennent des « poupées russes » qui s’ouvrent en 2 parties et qui contiennent …

A la différence des « poupées russes », cette structure de déclarations peut contenir récursivement  non pas une mais plusieurs structures contiguës.

Une fonction renvoie un résultat par le biais de résult

Cette partie

aussi est facultative

En supprimant les parties facultatives, il reste le programme le plus simple que l’on puisse écrire.

Il s’agit d’une application console, la plus simple possible que vous pouvez compiler et exécuter depuis la ligne de commande program Kedal; {$APPTYPE CONSOLE}

Remarques :

o Ce qui est entre accolades { } est un commentaire (et donc ignoré du compilateur), mais o S’il y a un $  collé contre l’accolade {$  }  ceci devient une directive de compilation. o Ne pas oublier le point-virgule (il sépare 2 instructions mais n’est pas une fin de ligne comme en ada et en C) à la fin de la première ligne et le point final.

Si Delphi est installé et si votre chemin d'accès contient le répertoire Delphi\Bin (où se trouvent les fichiers et ), vous pouvez saisir ce programme dans un fichier appelé ou mieux à l’aide d’un éditeur texte (comme le bloc-notes de windows) puis le compiler en saisissant, dans une fenêtre dos, la ligne  (il peut être nécessaire d’ajouter les chemins): 

DCC32 Kedal sur la ligne de commande qui produira l'exécutable résultant () dont la taille est d’environ 37 ko. On peut l’exécuter en tapant sur la ligne de commande : 

Kedal

Si l‘on double-clique sur   dans la fenêtre de l’explorateur, une fenêtre console va s’ouvrir et se refermer immédiatement puisque ce programme ne fait rien (mais il le fait bien) dans la mesure où il ne contient aucune instruction. Ainsi, on peut « bloquer » l’exécution en ajoutant l’instruction readln qui attend que l’utilisateur ait tapé sur des touches du clavier (éventuellement aucune) puis sur la touche entrée. Il est d’ailleurs possible, avec readln(x), de mémoriser dans une variable x par exemple, ce que l’utilisateur a tapé. On aura déclaré x avant le begin. On préviendra l’utilisateur auparavant grâce à un message au moyen de writeln(‘Appuyez sur entrée’). Tout ceci donne : program Kedal; {$APPTYPE CONSOLE} begin

  writeln(‘Appuyez sur entrée’) ;  readln  end.

Mis à part sa simplicité, cet exemple diffère largement du type de programme que vous allez probablement écrire avec Delphi. Tout d'abord, c'est une application console. Delphi est généralement utilisé pour écrire des applications Windows ayant une interface graphique ; ainsi, dans une application Delphi vous ne devez normalement pas appeler Writeln. De plus, la totalité du programme exemple (à l'exception de Writeln) se trouve dans un seul fichier. Dans une application Delphi, l'en-tête du programme (la première ligne de cet exemple) se trouve dans un fichier projet séparé qui ne contient pas la logique réelle de l'application sinon quelques appels aux méthodes définies dans les fichiers unité.

  Utiliser des unités

Il est possible, selon la nature des applications, d’utiliser ou non certaines bibliothèques qui contiennent fonctions, procédures et autres objets divers et variés. Le noyau se situe dans une unité nommée system qu’il est inutile de déclarer :

on aurait très bien pu mettre :

 uses system ;  dans le programme précédent, ça n’aurait rien changé).

Writeln et readln font partie du noyau de delphi, alors que le programme : program Kedal;

{$APPTYPE CONSOLE} uses  dialogs; begin

  ShowMessage('Cliquez pour quitter’) ; end.

Le programme précédent va, en  plus de l’application console, ouvrir une boîte avec un message et un bouton. Lorsque l’on clique sur le bouton, on ferme la boite à message ce qui a pour effet de terminer l’application puisque ShowMessage est la dernière instruction du programme.

1.   Créer des unités
2.   Les projets

L'exemple suivant propose un programme constitué de deux fichiers : un fichier projet et un fichier unité. Le fichier projet, que vous pouvez enregistrer sous le nom , a la forme suivante :

…

La première ligne déclare un programme appelé Kedal qui, encore une fois, est une application console. La clause uses

UnitStop; spécifie au compilateur que Kedal inclut une unité appelée UnitStop. Enfin le programme appelle la procédure Stop. Mais où se trouve la procédure Stop ? Elle est définie dans UnitStop. Le code source de UnitStop (colonne de droite) que vous devez enregistrer dans un fichier appelé

UnitStop définit une procédure appelée Stop. En Pascal, les routines qui ne renvoient pas de valeur sont appelées des procédures. Les routines qui renvoient une valeur sont appelées des fonctions. Remarquez la double déclaration de Stop dans UnitStop. La première déclaration, après le mot réservé interface, rend Stop accessible aux modules (comme Kedal) qui utilisent UnitStop. Le seconde déclaration, placée après le mot réservé implémentation, définit réellement Stop.

Vous pouvez maintenant compiler Kedal depuis la ligne de commande en saisissant :

DCC32 KEDAL

Il n'est pas nécessaire d'inclure UnitStop comme argument de la ligne de commande. Quand le compilateur traite le fichier

, il recherche automatiquement les fichiers unité dont dépend le programme Kedal. L'exécutable résultant

() fait la même chose que le premier exemple : Rien de plus que d’afficher un message et d’attendre que l’utilisateur appuie sur entrée.

Utiliser des unités o évite au compilateur de recompiler une partie de code si le programmeur n’a pas modifié l’unité correspondante o permet au programmeur de fournir un fichier .DCU (Unité Delphi Compilée) et un mode d’emploi rendant cette unité parfaitement utilisable tout en protégeant son code.

  Fichiers d’un projet

En général, on regroupe tous ces fichiers (il peut y avoir plus d’une unité, et même d’autres fichiers ) dans un répertoire le fichier dpr en faisant partie lui aussi. On y trouve notamment : 

III. Éléments de syntaxe

  Commentaires

Les commentaires se placent entre accolades ou parenthèses et étoiles ou derrière 2 slaches:

{ceci est un commentaire}

(*ceci est un autre commentaire*)

// tout ce qui suit et jusqu’à la fin de ligne est aussi un commentaire

  Directive de compilation

Comme les commentaires, elles se mettent entre { }, mais la première accolade est suivie de $. Ce $ est lui-même immédiatement suivi de la directive. Ce ne sont pas des instructions du langage, elles servent à donner des instructions au compilateur, par exemple:

•    Pour mettre au point un programme, on peut avoir besoin d’ajouter des instructions que l’on effacera dans la version définitive.

{$Define test}

{$IFDEF test}

{$ENDIF}

On compile le programme de cette manière pendant les tests, puis il suffit d’insérer un espace avant le $

{ $Define test}

pour transformer cette ligne en commentaire et de ce fait inhiber la définition test et par conséquent dé valider les instructions comprises entre le {$IFDEF test} et {$ENDIF}

•    Pour écrire des programmes portables sous Windows et Linux :

uses

{$IFDEF WIN32}

  Windows, Messages, Graphics, Controls, Forms, Dialogs, Menus, StdCtrls, Buttons, ExtCtrls, MMSystem,  ComCtrls,

{$ENDIF} {$IFDEF LINUX}

  QGraphics, QControls, QForms, QDialogs, QMenus, QStdCtrls, QButtons, QExtCtrls, QComCtrls,

{$ENDIF}

  SysUtils, Classes;

WIN32 ou LINUX sont automatiquement définis selon le Système d’Exploitation sous lequel on compile. Dans l’exemple précédent, les bibliothèques correspondant au bon S.E. seront utilisées. SysUtils et Classes étant communes aux 2 S.E.

•    Pour forcer le compilateur à effectuer ou non certaines vérifications. Ce sont des directives bascules. Par exemple:

{$B+} Force l’évaluation complète des booléens alors que {$B-} effectue l’évaluation partielle (Voir le type booléen) {$R+} Vérifie le non-débordement des tableaux. Alors que {$R-} permet de définir un tableau de 5 cellules et l’écriture d’une valeur dans la 6éme ne déclenchera pas d’erreur (Mais aura pour conséquence d’écraser peut-être d’autres variables en mémoire). Il est clair que la vérification du non-débordement une sécurité dans le déroulement du programme mais aussi génère des instructions machines supplémentaires et donc ralentissent le déroulement du programme. On peut cumules ces directives bascules et même les commenter:

{$B+,R-,S-}

{$R- Désactive la vérification des limites}

•    On peut aussi utiliser ces directives dans la ligne de commande: (Ne pas oublier le /): DCC32 MonProg  /$R-,I-,V-,U+

Pour les autres directives comme $I, $L etc., on se référera à l’aide de Delphi.

En utilisant L’EDI, Ces directives sont générées automatiquement et rassemblées dans un fichier DOF, DSK CFG 

  Identificateurs

Un identificateur commence obligatoirement par une lettre ou un trait-bas suivi de lettres, chiffres ou trait-bas à l’exclusion de tout autre caractère. Les caractères accentués sont aussi interdits. Comme en ADA et contrairement à C et Java, il n’y a pas de différence entre majuscule et minuscules.

  Identificateurs qualifiés

Quand vous utilisez un identificateur qui a été déclaré à plusieurs endroits, il est parfois nécessaire de qualifier l'identificateur. On utilise un point entre les 2 identificateurs. 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 MaVar, vous pouvez désigner MaVar de Unit2 en écrivant : Unit2.MaVar

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

Form1.Button1.Click

Appelle la méthode Click de Button1 dans Form1.

Si vous ne qualifiez pas un identificateur, son interprétation est déterminée par les règles de portée décrites dans Blocs et portée.

  Affectation

On utilise le symbole := pour donner une valeur à une variable. Par exemple:

a:=5; b:=‘Bonjour’;

Ou encore Pour permuter les valeurs des variables x et y : 

t:=x; x:=y; y:=t;

  Séparateur d’instruction.

Contrairement à d’autres langages (C, ADA, etc.) le Point-virgule n’est pas une fin d’instruction mais un séparateur. C’est à dire qu’il ne se place pas systématiquement à la fin d’une instruction, mais entre 2 instructions. En particulier il n’y a pas lieu de mettre un point-virgule avant un end même si le compilateur le tolère alors que le point-virgule devant un else provoque une erreur de compilation