(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 .
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.
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 :
|
Extension du fichier |
Description et Commentaires |
|
DPR |
(Delphi PRoject) Contient l'unité principale du projet |
|
PAS |
(PAScal) Contient une unité écrite en Pascal. Peut avoir un .DFM correspondant |
|
DFM |
(Delphi ForM : fiche Delphi) Contient une fiche (une fenêtre). Le .PAS correspondant contient toutes les informations relatives au fonctionnement de cette fiche, tandis que le .DFM contient la structure de la fiche (ce qu'elle contient, sa taille, sa position, …). Sous Delphi 5, les .DFM deviennent des fichiers texte qu'il est possible de visualiser et de modifier. La même manipulation est plus délicate mais possible sous Delphi 2 à 4. |
|
DCU |
(Delphi Compiled Unit : Unité compilée Delphi) Forme compilée et combinée d'un .PAS et d'un .DFM optionnel |
|
~??? |
Tous les fichiers dont l'extension commence par ~ sont des fichiers de sauvegarde, pouvant être effacés pour faire place propre. |
|
EXE |
Fichier exécutable de l'application. Ce fichier est le résultat final de la compilation et fonctionne sous Windows exclusivement. Pour distribuer le logiciel, copier ce fichier est souvent suffisant. |
|
RES |
(RESsource) Fichier contenant les ressources de l'application, tel son icône. Ce fichier peut être édité avec l'éditeur d'images de Delphi. Ces notions seront abordées plus loin dans ce guide. |
|
DOF DSK CFG |
Fichiers d'options : suivant les versions de Delphi, ces fichiers contiennent les options du projet, les options d'affichage de Delphi pour ce projet, |
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:
{$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}
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.
{$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}
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
