Delphi 7

Chapitre I Description de l’environnement Delphi
I. Description de l’environnement Delphi :

Introduction :
Avant l’apparition de la programmation visuelle, les programmeurs passaient beaucoup
de temps à écrire du code instruction par instruction, en prenant soins du moindre détail,
la détection d’une erreur de syntaxe prend énormément de temps car il n’y a aucun
moyen de la repérer automatiquement.
L’apparition des langages tels que Delphi, Visual Basic, C++Builder…. A permis de
rendre la vie plus facile, grâce à l’environnement de développement intégré (EDI), qui
offre la possibilité de créer des applications complètes sans écrire aucune ligne de code.
Comme beaucoup de logiciels, Delphi existe en plusieurs versions (Delphi1,...,
Delphi7, Delphi 2006,…, Delphi 2010, Delphi XE).
Dans le présent manuel, on utilise la version 7 qui est fournie sur CD avec cet ouvrage.
Dans ce chapitre, le stagiaire va découvrir l’environnement de développement intégré
propre à Delphi.
Nous ne décrirons pas ici la procédure d'installation de DELPHI à partir

du CD ou d’un fichier téléchargé, elle ne présente pas de difficulté, il suffit
de suivre les indications apparaissant à l'écran.
I.1. Définition de Delphi :

Delphi est un outil de développement, c'est-à-dire un programme qui permet de
fabriquer des programmes.
Delphi est un environnement de programmation visuel orienté objet pour le
développement rapide d’applications (RAD).
 C’est un logiciel de conception d’applications fonctionnant sous Windows.
 Un peu de vocabulaire :
« POO » programmation orienté objet : c’est une façon de développer et de présenter
une application informatique sous la forme d’objets, ayant des propriétés.
« Programme » : texte écrit dans un langage informatique, comportant dans notre cas
des instructions structurées. Il est destiné à être « converti » par Delphi en un logiciel
utilisable sous Windows.
« Développer en Delphi » : écrire des programmes en utilisant Pascal.
« Application » : Logiciel fonctionnant sous Windows.
« Projet » : c'est la base d'une application. Sous Delphi, pour créer une application, on
constitue d'abord un projet.
1
« Code » : (Code Pascal, Code source) : morceau de programme, texte d'un programme
écrit en Pascal.
« Interface (utilisateur) » : la partie d'un logiciel qui est visible par l'utilisateur, à
l'opposé du code source, invisible à l'utilisateur.
« Fiche » : fenêtre à l'état non compilé. Les fiches sous Delphi ou fenêtres sous
Windows.
I.2. Définition de Pascal Objet :
Le langage de programmation utilisé par Delphi est le PASCAl ou plus exactement le
PASCAL Objet.
Le Pascal est un langage qui sert de support à Delphi. La version utilisé par Delphi est
une version enrichie appelée Pascal Objet qui permet la programmation orienté objet
dans l'environnement Windows. Donc on parle ici du langage Pascal sous Delphi.
Objet = enregistrement + procédures + fonctions
I.3. Description de l’environnement de développement intégré Delphi (EDI):
On appel EDI « Environnement de Développement Intégré », l’interface qu’offre
Delphi pour aider l’utilisateur à construire son application. Cette interface ressemble à
un atelier où l’on dispose d’une boite à outils et d’un ensemble d’objets.
Vous pouvez démarrez Delphi de plusieurs façons :
 Double cliquer sur l’icône Delphi (si vous avez créez un raccourci).
 Choisir Tous les Programmes/Borland Delphi 7/Delphi 7 dans le menu
Démarrer de Windows.
 Choisir Exécuter dans le menu Démarrer puis entrer Delphi 32.
 Double cliquer sur Delphi32.exe dans le répertoire Delphi/Bin.
Au lancement du logiciel l’écran a l’aspect ci-dessous :
2 1
Figure 1 : la fenêtre Delphi 7

La partie supérieure de l'écran donne accès au système de menus et à la barre d'outils.
2
I.3.1. La barre des menus :

La fenêtre principale (fig2), en haut de l’écran, contient le menu principal, les barres
d’outils et la palette des composants.
Barre de menus
Barre d’outils
Figure 2 : la fenêtre principale Palette de composants
Delphi présente des menus comme toutes applications Windows. Vous ne trouverez
aucune ambiguïté quant à leur utilisation.
La barre de menus permet d'accéder à la plupart des commandes disponibles.
 Le menu Fichier permet d'ouvrir un nouveau fichier, un nouveau projet,

d'enregistrer votre travail et d'imprimer.
 Le menu Edition donne accès aux fonctions copier coller classiques ainsi qu'a des
outils de présentation,
 le menu Recherche permet d'effectuer des recherches dans de longs
programmes,
 le menu Voir permet d'avoir accès aux différentes fenêtres de Delphi, d'afficher
des éléments constituant une application,
 le menu Projet permet d'accéder aux commandes spécifiques au projet en cours.
 le menu Exécuter permet la compilation et l'exécution d'un programme.
 le menu Outils donne accès à divers outils de Delphi, donc un seul est vraiment
intéressant : l'éditeur d'images.
 Le menu Aide, enfin, permet d'accéder à l'aide du logiciel.
Il ne s'agit pas ici de connaître chacun des éléments de menus de Delphi,

c'est inutile à ce stade car certaines commandes ne servent qu'en de
rares occasions.
Il est cependant essentiel de vous familiariser avec les commandes les
plus utiles pour la gestion des projets : Nouveau…, Ouvrir, Enregistrer,
Enregistrer sous…, Fermer.
3
I.3.2. La barre d’outils :

Dans la partie gauche de la fenêtre principale (revoir fig 2), se trouve les barres d’outils.
Les barres d’outils de Delphi permettent l’accès rapide aux opérations et aux
commandes les plus utilisées. La plupart des opérations accessibles dans les barres
d’outils se retrouvent dans les menus déroulants.
 Voici quelques barres d’outils :
Nouveau ouvrir enregistrer tout ajouter un fichier

au projet
Enregistrer ouvrir un projet Retirer un fichier

du projet
Figure 3 : barre d’outils standard
Voir une unité Basculer fiche/unité
Voir une fiche nouvelle fiche
Figure 4 : barre d’outils Voir
I.3.3. La palette des composants :

La palette de composants (fig 6) est constituée de pages à onglets où des groupes
d’icônes appelées « composants ». Les pages regroupent les composants selon leurs
diverses fonctionnalités.
 C’est quoi un composant ?
Un projet Delphi est constitué de plusieurs éléments qu’on appelle composants. Le
composants serai donc un un programme (petit projet) qui exécute une tâche
élémentaire ou une fonction déterminée, ce programmae est crée puis inséré dans la
palette pour une réutilisation probable.
4
Figure 5: structure interne d'un composant
Les plus couramment utilisés sont ceux de l’onglet "Standard".

Les autres onglets « Supplément, Win32,… » etc donnent accès à d'autres objets, nous
en rencontrerons quelques uns par la suite .
Chaque composant possède des attributs spécifiques (propriétés, événements et
méthodes) vous permettant de contrôler votre application.
Composants
Figure 6 : palette des composants
Composant Utilisation
Cadre Composant cadre (nouveau): sert de conteneur de composants
MainMenu Menu principal
PopupMenu Menu surgissant
Label Texte en lecture seule pour l'utilisateur (ex: titre)
Edit Texte en lecture-écriture modifiable par l'utilisateur (zone de saisie)
Memo Mémo: comme le composant précédent, mais possibilité d'utiliser plusieurs
lignes de texte
5
Button Bouton d'action: c'est le composant le plus utilisé

CheckBox Case à cocher. Propose une option que l'utilisateur peut faire passer de Oui à
Non ou de Vrai à Faux. Les cases à cocher peuvent servir à afficher un
groupe de choix qui ne sont pas mutuellement exclusifs. Les utilisateurs
peuvent sélectionner plusieurs cases à cocher dans un groupe.
RadioButton Bouton radio. Propose une option que l'utilisateur peut faire passer de Oui à
Non ou de Vrai à Faux. Les boutons radio peuvent servir à afficher un
groupe de choix qui sont mutuellement exclusifs. Les utilisateurs ne
peuvent sélectionner qu'un seul bouton radio par groupe.
ListBox Boîte liste. Affiche une liste déroulante de choix.
ComboBox Boîte à options. Affiche une liste de choix en combinant une boîte liste et
une boîte de saisie. Les utilisateurs peuvent saisir des données dans la boîte
de saisie ou sélectionner un élément dans la zone boîte liste.
ScrollBar Barre de défilement. Propose un moyen de modifier la zone visualisée
d'une liste ou d'une fiche. Une barre de défilement peut également être
utilisée pour se déplacer par incréments dans un intervalle de valeurs.
GroupBox Boîte groupe. Sert de conteneur à des options associées dans une fiche.
RadioGroup Groupe de boutons radio. Crée une boîte groupe qui contient des boutons
radio sur une fiche.
Panel Volet. Crée dans une fiche des volets pouvant contenir d'autres composants.
Les volets peuvent servir à créer des barres d'outils ou des lignes d'état.
ActionList Composant permettant la centralisation du code événementiel
Tableau 01: Les composants de la page Standard
 Comment utiliser les composants de la palette ?

Pour déposer un composant sur une fiche, il faut d’abords sélectionner l’onglet où il se
trouve, il suffit ensuit de cliquer sur le composant en question et le déposer ensuite sur la
fiche en faisant un simple clic à l’endroit voulu.
I.3.4. La fiche et l’unité :
a) La fiche ou « form » est la fenêtre que vous allez voir lorsque vous lancez le
programme.
Pour l'instant, elle est vide, mais c'est là que vous pouvez rajouter les objets (les menus,
les boutons …etc), vous pouvez l'agrandir, la réduire, bref, faire tout ce que vous
voulez sans taper une ligne de code...
Une application peut comporter plusieurs fiches.
6
Composants Composants
Label Edit
Composant
Button
Figure 7 : exemple de fiche

b) L’unité : L'éditeur de code ou « unité » est généralement caché sous le
concepteur de fiche, cette fenêtre contient le code de votre programme (fig 8).
 Appuyer sur la touche F12 pour l’amener en premier plan.
 Comme vous le voyez, il y a déjà du code écrit alors que vous n’y êtes pour rien.
 A ce propos, la relation entre une fiche et son unité est non modifiable.
Figure 8 : exemple d’unité
Attention cependant à ne pas tomber dans l'excès : certaines unités

n'auront absolument pas besoin de fiche correspondante (des unités
comportant exclusivement des calculs mathématiques par exemple).
7
Il n'est pas conseillé de modifier ce qui a été écris par l’éditeur de

code, si vous voulez supprimer un bouton par exemple, ne l'effacez pas
directement dans le code, mais effacez-le graphiquement : le
compilateur s'occupera du reste.
I.3.5. L’inspecteur d’objet :

L'inspecteur d'objets de Delphi (fig 9) affiche l’ensemble des propriétés et l’ensemble
des évènements associés à un composant.
S’il n’est pas visible, appuyer sur la touche F11 pour le faire apparaitre.
 L'inspecteur d'objets vous permet de modifier les propriétés et d'accéder aux

événements des composants et des fiches.
 L'inspecteur d'objets comporte deux pages :
Page propriétés qui vous permet, en mode conception, de définir les propriétés des
composants de votre fiche, mais aussi celles de la fiche.
Page Evénements : qui vous permet d'associer des événements aux objets de votre projet.
Trois utilisations sont possibles:
Utilisation Effet
double-clique à coté de l'événement création automatique d'un entête de
procédure par défaut
introduction d'un nom de procédure création automatique d'un entête de
procédure avec le nom choisi
ouverture d'une liste déroulante (s'il y a choix d'une procédure commune à plusieurs
déjà des procédures compatibles) événements
Tableau 02 : utilisation des événements
Ici, on peut voir qu'il s'agit des caractéristiques générales

de la fenêtre car on voit "Form1: TForm1".
Figure 9 : l’inspecteur d’objets
8
I.4. Exercice théorique :

Choisir la bonne réponse :
1. Delphi est un :
a. Langage de programmation visuelle
b. Logiciel de conception des applications sous Windows.
c. Logiciel bureautique
2. Dans le vocabulaire de Delphi, une fiche est
a. Une interface utilisateur en construction
b. Un " contrôle " à placer dans une interface utilisateur
c. Un programme d'ordinateur
3. Dans le vocabulaire de Delphi, un composant est
a. Un programme d'ordinateur
b. Un "contrôle" à placer sur une fiche
c. Une interface utilisateur
4. Le contenu d’une unité est modifiable manuellement :
a. Vrais
b. Faux
5. La touche qui permet de basculer entre la fiche et son unité correspondante
est :
a. F5
b. F12
c. F10
6. Si l’inspecteur d’objet n’est pas visible, on peut le faire apparaitre à travers la
touche :
a. F11
b. F12
c. F9
I.5. Exercice pratique :
- Placer deux boutons sur une fiche comme si indiqué dans l’image suivante.
- Quelle sont les propriétés utilisées sur la fiche ?

- Quelles sont les propriétés utilisées sur les deux boutons ?
9
I.6. Résumé :
Voilà, vous en savez maintenant assez sur Delphi pour le moment :

 Delphi n'est qu'un enrobage, une enveloppe de confort autour de
Pascal,
 Delphi est destiné à écrire des programmes fonctionnant
exclusivement sous Windows.
 Delphi permet d'utiliser le langage Pascal.
 Pascal est un langage informatique,
 Delphi est un logiciel destiné à créer des logiciels avec ce langage.
 Un projet permet de regrouper le programme principal ainsi que
toutes les fiches (fenêtres) et unités utilisées.
 Delphi permet de créer des programmes en utilisant des éléments
prédéfinis : les fiches et les composants.
 Chaque élément, à l'exception des fiches, est accessible dans la palette
des composants.
 Chaque fiche, chaque composant possède une liste de propriétés et
une liste d'évènements accessibles dans l’inspecteur d’objets.
10
I.7. Exercice de synthèse :
Spécialité : Informatique / Option : Bases de Données

Module : Delphi Monoposte « Implanter les Bases de Données en Monoposte »
Durée : 30 mn
But : utilisation des propriétés des objets
Matériels requis :
 Micro ordinateur
 SGBD (Delphi7)
Mise en situation :
Dans cet exercice, vous devez créer l’interface suivante :
Marche à suivre :
 Etape 1 : déposer les composants sur la fiche

 Etape 2 : affecter les propriétés aux composants.
11
Chapitre II Créer une application simple
II. Créer une application simple :

Introduction :
Un projet regroupe l’application et tous les fichiers associés, une application devient
projet quand celle-ci est sauvegardée sur disque.
Dans ce chapitre, vous allez découvrir comment créer une simple application avec
Delphi 7.
Pour le faire, vous devez passer par les étapes suivantes :
• Etape 1 : créer la (ou les) fiche(s).
• Etape 2 : placer les composants sur les fiches et attribuer les propriétés pour
chaque composant.
• Etape 3 : associer des évènements aux composants
• Etape 4 : enregistrer le projet
• Etape 5 : compiler et/ou exécuter l’application.
II.1.Créer un nouveau projet:
Delphi permet de créer une seule application à la fois, ouverte en tant que projet.
 Un projet est l’état non compilé d’une application

 Un projet est une collection de fichiers qui sont soit créés au moment de la
conception soit générés lorsque vous compilez le code source du projet
1ere étape : création des fiches :

Au lancement de Delphi, une fiche est crée automatiquement, portant le nom « form1 »
par défaut.
Pour créer d’autres fiches, il suffit d’utiliser l’outil « Nouvelle fiche » dans la
barre d’outils « voir » ; ou bien Fichier/Nouveau/Fiche
2eme étape : placement des composants sur la fiche et attribution des propriétés :
Pour placer un composant sur la fiche, il suffit de cliquer sur son icône dans la palette
des composants puis cliquer dans l’endroit voulu sur la fiche, ou bien double cliquer sur
le composant, il sera inséré directement sur la fiche.
 Exemple : un bouton placé sur ne fiche :
3eme étape : associer des évènements aux composants :

Dans l’exemple précédent (étape2), le bouton déjà placé sur la fiche v
A nous servir à quitter le programme.
Pour le faire, il suffit de double cliquer sur le bouton, puis introduire la ligne de code
suivante entre le begin et le end:
12
Figure 10 : éditeur de code
Ou bien :
Activer l’onglet évènement de l’inspecteur d’objet, puis double cliquez dans la case
blanche en face de l’événement « OnClick », introduisez en suite la même ligne de
code :
Application.Terminate ;
Vous allez avoir le même résultat.
 Un autre exemple :
Placez un Bouton et un Label sur la fiche
comme suit :
Lorsqu’on clique sur le bouton OK, le label change de valeur et devient : « je suis un
débutant ».
 Pour cela : double cliquez sur le bouton OK, puis introduire cette ligne de code :
Label1.caption := ‘je suis un débutant ‘ ;
 Exécutez maintenant.
Voici le résultat :
4eme étape : enregistrer le projet

5eme étape: compiler et/ou exécuter l’application.
Nous allons voir ensemble ces 2 étapes (4 et 5) dans ce qui suit.
13
II.2.Sauvegarder le projet :
En cliquant sur le menu Fichier ⇒ Tout Enregistrer, ou sur l’outil 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 , choisissez le nom de votre unité,
il faut ensuite entrer le nom du projet , par défaut Project1 que vous changez en nom
de votre projet.
Il est utile de consacrer complètement un répertoire (dossier) à

chaque projet.
Figure 11 : enregistrement de l’unité
Figure 12 : enregistrement du projet

II.3.Les fichiers créés dans un projet Delphi :
Une application Windows est constituée de fenêtres. Le projet Delphi qui génère
l’application contient donc ces fenêtres : les fiches.
A chaque fiche est adjointe une seule unité.
Un projet Delphi est constitué d’un fichier projet, d’unités et de fiches.
 Le fichier projet porte l’extension « .DPR »
14
 Chaque fiche est stockée dans un fichier avec l’extension « .DFM »

 Chaque unité est stockée également dans un fichier portant l’extension « .PAS »
 La fiche et son unité associée portent le même nom de fichier (Delphi ne
demande ce nom qu’une seule fois et l’utilise pour l’unité et pour la fiche)
Exemple: si la fiche est stockée dans un fichier Somme.DFM, son unité associée sera
stockée dans le fichier Somme.PAS.
Il est possible d’utiliser des unités qui ne sont associées à aucune fiche.
.dfm fiche
Nom de base + associés
.pas unité
Fichiers contenu des fichiers
Figure 13 : les fichiers d’un projet Delphi
Extension du
Description et Commentaires
fichier
Avant l’exécution
DPR (Delphi Project) Contient l'unité principale du projet
(PAScal) Contient une unité écrite en Pascal. Peut avoir un .DFM
PAS
correspondant
DFM (Delphi ForM) fiche Delphi
Après l’exécution du projet
(Delphi Compiled Unit) (Unité compilée Delphi) Forme compilée
DCU
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.
Fichier exécutable de l'application. Ce fichier est le résultat final de
EXE
la compilation et fonctionne sous Windows exclusivement.
(RESsource) Fichier contenant les ressources de l'application, tel
RES
son icône…
DOF Fichiers d'options : suivant les versions de Delphi, ces fichiers
DSK contiennent les options du projet, les options d'affichage de Delphi
CFG pour ce projet, ...
Tableau 03 : les fichiers d’un projet Delphi
15
II.4.Exécuter un projet :
Pour exécuter un projet Delphi, utilisez Fichier Exécuter ou bien cliquer sur l’outil
Exécuter .
 La compilation de projet :
Vous pouvez vérifier la syntaxe du code, compiler ou exécuter directement le projet.
Pour disposer d'un exécutable, il est nécessaire de compiler. En cas d'erreur, la
compilation s'arrête et visualise un message d'erreur.
Pour le faire :
Dans le menu Projet, sélectionnez la commande Compiler « nom du projet », ou bien
utiliser la combinaison (ctrl+F9)
Si vous ne voyez pas cette fenêtre pendant la compilation, ne vous inquiétez pas, vous
pouvez la faire apparaitre :
Menu outils/Options d’environnement, dans l’onglet Préférences cochez la case Afficher
la progression.
Après quelques instants de travail, le logiciel nous redonne la main. La compilation a eu

lieu : le code machine se trouve
• dans la mémoire de l'ordinateur ;
• dans ton répertoire personnel, sous la forme d'un fichier exécutable (.exe).
Notre programme peut maintenant être exécuté.
Figure 14 : compilation d’un projet
 Exécuter le programme :
Dans le menu Exécuter, sélectionnez la commande Exécuter ou cliquez sur l'outil
ou frappe la touche F9.
 Lors de la compilation, chaque fiche (fichier .DFM) avec son unité (fichier
.PAS) seront transformées en un seul fichier (.DCU).
 Tous les fichiers « .DCU » seront transformés en un seul fichier exécutable
« .EXE » qui représente l’application Delphi générée.
 Le fichier « .EXE » porte le même nom que le fichier projet « .DPR ».
16
Fichier projet
.DPR
Unité 1 Fiche1 Fichier 1

.PAS .DFM .DCU Application
Fichier.exe
Unité 2 Fiche2 Fichier 2 Fenêtre Fenêtre

.PAS .DFM .DCU 1 2
Pas de
Unité 3 fiche Fichier 3
.PAS associée .DCU
Projet Compilation Application
Figure 15 : compilation d’un projet
II.5.Ajouter des nouvelles fiches :

Pour ajouter une fiche à votre projet, sélectionnez Fichier/Nouvelle fiche, ou bien
cliquez sur l’icône Nouvelle fiche dans la barre d’outils « voir » (fig16).
Toutes les fiches d’un projet ainsi que les unités correspondantes sont affichées dans le
gestionnaire de projet (Voir/Gestionnaire de projet) (fig 17), et vous pouvez afficher la
liste des fiches en choisissant Voir/Fiches (Maj+F12).
Figure 16 : insérer une nouvelle fiche
17
Figure 17 : gestionnaire de projet

 La ligne de code : nom de la fiche.show ; permet d’appeler une fiche à partir
d’une autre.
 Exemple : form2.show ; (form2 : est le nom de la fiche « propriété : name »)
Informations très importantes :

Chaque fois que l'on commencera un nouveau projet on veillera à
l'enregistrer (dès sa création) dans un nouveau dossier.
Veillez à donner un nom représentatif aux fiches, aux unités et même aux
composants.
Ne fermez jamais une des fenêtres en cliquant sur la croix rouge en haut
à droite. Elles doivent toujours être ouvertes simultanément !!
II.6.Exercices pratiques :
Exercice1 :
Cet exercice vise à réaliser une application qui effectue les opérations suivantes :
 Insertion de deux boutons sur une fiche.
 Insertion d’un Label dont la description est « Bienvenue ».
 Lorsqu’on clique sur le 1er bouton, dont le contenu est « Go », le label change de
valeur et devient : « voici ma première application ».
 Lorsqu’on clique sur le 2eme bouton, dont le contenu est « quitter »,
l’application ce termine.
18
Ce qu’on souhaite obtenir :
Lorsqu’on clique sur le bouton Go, la fenêtre devient comme suit :
Exercice2 : refaire la même chose avec un composant « Edit » au lieu d’un Label.
19
II.7.Résumé :
A l’issue de chapitre, nous avons montré:

Quels sont les principes de base à utiliser pour construire une
application avec Delphi.
Et que :
Delphi permet de créer une seule application (un futur logiciel) à la
fois, ouverte en tant que projet.
Un projet est l'état non compilé d'une application.
Chaque projet compilé devient une application.
La relation entre une fiche et son unité est non modifiable.
Avec quelques lignes de codes, il est possible de construire une
application fonctionnelle, sûre et d’un aspect propre.
II.8.Exercice de synthèse :

Durée : 45 mn
But : création et enregistrement d’une application simple
Matériels requis :
 SGBD (Delphi7)
Mise en situation :
Cet exercice vise à créer une application qui effectue les opérations suivantes :
 Créer une application qui ce compose de deux fenêtres.

 La 1ere fenêtre contient les composants suivants :
o Un bouton « Continuer »
o Un bouton « Quitter »
o Deux Labels.
20
 le bouton « continuer » permet d’appeler une 2eme fenêtre qui comporte les
composants suivants :
 5 composants Label
 Un bouton « Fermer ».
Ce qu’on souhaite obtenir :
Lorsqu’on clique sur le bouton « continuer », la fenêtre suivante s’affiche :

21
Marche à suivre :
 Etape 1 : création d’un nouveau projet

 Etape 2 : enregistrement du projet
 Etape 3 : création et enregistrement des fiches.
 Etape 4 : saisie du code nécessaire
22
Chapitre III Définir les propriétés et les événements d’un objet
III. Définir les propriétés et les événements d’un objet :

Introduction :
Comme on la déjà vu, l’inspecteur d’objets est composé de deux onglets : Propriétés et
Evènement.
L’onglet Propriétés affiche une liste de propriétés pour chaque composant inséré sur la
fiche.
L’onglet événements dans lequel on trouve tous les événements que peut déclencher un
objet.
Dans ce chapitre vous allez découvrir la notion de propriété, d’un événement, les
événements et propriétés les plus importants ainsi que l’attribution et la modification de
ces derniers.
III.1. Définition d’une propriété :
Les propriétés sont un ensemble de caractéristique d’un composant. Par exemple : son
nom, sa taille, sa position, sa couleur, son intitulé…..etc
On peut dire aussi que les propriétés sont des paramètres réglables d’un composant.
III.2. Modifier la valeur d’une propriété :
Comme on l’a déjà dit, l’onglet Propriétés de l’inspecteur d’objets affiche une liste de
propriétés pour chaque composant inséré sur la fiche, si aucun composant n’est inséré,
l’inspecteur d’objets affiche les propriétés relatives à la fiche.
III.2.1. En mode création :
Deux moyens pour modifier les propriétés d’un composant :
a) Utilisation Delphi :
Manipulation visuelle : Par l’inspecteur d’objets :
Par exemple pour dimensionner Le composant

un composant, il faut le sélectionner
puis déplacer les poignées avec la
souris.
La
propriété
La valeur de la
propriété
Figure 18: modifier les propriétés d'un bouton

23
 Certaines propriétés possèdent des sous

propriétés, celles-ci sont précédées d’un signe
« + », il suffit de cliquer dessus pour voir apparaitre les propriétés.
 D’autres propriétés proposent un choix de valeur

parmi lesquelles il faut en sélectionner une. Par
exemple : la propriété « Align » :
 D’autres propriétés prennent deux valeurs

possibles « True » ou « False ».
Par exemple : la propriété « Enabled » :
 Exemple :
Pour illustrer l’utilisation des propriétés, essayons d’insérer un composant dans la fiche et
attribuons-lui ses différentes propriétés :
 Insérez le composant « label », de la palette des composants standard, symbolisé par
, pour cela cliquez sur le composant et déposez le sur la fiche en cliquant sur
l’endroit voulu.
 Dans l’inspecteur d’objets :

 Visualisez la propriété « Name », par défaut, elle est Label1, vous pouvez la
changer ou la garder.
 Sélectionner la propriété « Caption » ; par défaut, Delphi lui affecte Label1,
changez cette valeur par « Bonjour tout le monde ».
 Développer la propriété « Font » en cliquant sur le signe « + », une liste de
propriétés apparait :
 Mettez la valeur « clRed » pour la propriété « Color » (couleur de
caractère).
 Mettez la valeur « Cambria » pour la propriété « Name » (nom de
police).
 Mettez la valeur « 16 » pour la propriété « size » (taille de police).
24
 Pour modifier la couleur de fond du Label, changer la valeur de la propriété

« Color », qui est placée juste après la propriété « Caption », en lui affectant
la valeur « clYellow ».
Voila ce qu’on va obtenir :
On voit bien que les propriétés agissent sur le composant dès la

conception, en revanche, il existe d’autres propriétés qui agissent
uniquement lors de l’exécution de l’application, pour voir essayer de
changer la valeur de la propriété « visible » et affectez lui la valeur
« false », vous remarquez aucun changement, cette valeur a pour effet de
rendre invisible le composant à l’exécution.
b) Utilisation du code :
Pour utiliser une propriété d’un composant dans du code pascal (précisément dans une
procédure interne à la fiche qui contient le composant) il faut écrire :
• Le nom du composant (sa propriété Name)

• Un point (.)
• Le nom de la propriété
Exemple1 :
Button2 . Height := 45;
Le composant La propriété
III.2.2. En mode exécution :

Ici, le changement de la valeur de la propriété n’apparait qu’après l’exécution du
programme.
 Exemple : Changement de couleur d'un composant de type Tedit :

• Sur une fiche, dépose un composant de type Tedit dont tu conserveras le
nom Edit1;
• Fais un double clic sur Edit1;
25
• Entre les mots begin et end, frappe l'instruction : Edit1.Color:=clred, comme sur
l'illustration ci-dessous.
• Compile et exécute ce programme.

• Tente de modifier la valeur indiquée dans le composant TEdit: il vire
immédiatement au rouge.
• Termine le programme en cliquant sur la case de fermeture .
• Recommence en choisissant une autre couleur. La liste des couleurs disponibles
est indiquée dans la propriété Color de l'objet Tedit dans l'inspecteur d'objets.
III.3. Les propriétés les plus importantes :

Chaque composant possède plusieurs propriétés. Un certain nombre d’entre elle sont
communs à la plupart des composants, à titre d’exemple : Name : tous les composants
ont un nom.
La propriété Name est particulièrement importante car elle permet d’accéder au
composant depuis les programmes. Par défaut, Delphi lui confère une valeur peu
explicite (ex. Form1, Button1…). Il est préférable d’utiliser des noms plus « parlants ».
Parmi les propriétés les plus utilisées, nous citons :
 Caption ( en français légende ) : c'est le texte qui apparaît dans l'objet considéré
 Color : la couleur
 Font : qui permet de choisir la fonte utilisée pour les caractères, taille et couleur.
 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é.
 Alignment : Contrôle le positionnement du texte dans le libellé.
 BorderStyle : Détermine le style de la bordure d’un objet.
 BorderWidth : Spécifie la largeur de la bordure du composant.
 Visible : type booléen, contient, TRUE : Pour rendre l’objet visible, et FALSE
sinon
 Enabled : type booléen, contient, TRUE : Pour rendre le contrôle de l’objet
accessible, et FALSE sinon
 Hint : Type String, contient la chaîne de texte apparaissant lorsque l'utilisateur
déplace la souris au-dessus du contrôle (l’objet).
 ShowHint : type booléen, contient True pour activer Hint, False sinon.
26
 TabOrder : type entier, indique la position du composant dans l'ordre de

tabulation.
 Heigh : type entier, détermine la hauteur de l’objet en pixels
 Left : type entier, détermine la coordonnée horizontale, exprimée en pixels
relativement à la fiche, du bord gauche d'un composant.
 Top : type entier, détermine la coordonnée verticale, exprimée en pixels
relativement à la fiche, du bord gauche d'un composant.
 Width : type entier, détermine la largeur de l’objet en pixels.
 Cursor : Spécifie l'image utilisée pour représenter le pointeur de la souris
lorsqu'il passe au-dessus de la région couverte par le composant.
III.4. Définition d’un événement :

Un événement peut être un clic ou un mouvement de souris, une touche frappée au
clavier, une casse cochée, une fenêtre affichée ou masquée….etc
Chaque objet possède des événements qui peuvent le gérer, certains événements sont
communs à tous les objets, d’autres sont spécifiques.
La presque totalité des composants déclenchent des évènements pendant l'exécution du
logiciel.
L'illustration ci-contre présente l'inspecteur d'objets
d'un composant de type Tedit. Parmi les évènements

auxquels il est sensible, on voit :
• OnChange : quand le contenu du composant

change ;
• OnClick : quand on y fait un clic de souris ;
• OnDblClick : quand on y fait un double clic ;
• OnEnter : quand on entre dans le composant
(début
• d'édition)
• OnKeyDown : quand on frappe une touche dans
• le composant ;
• ... Figure 19 : l’onglet évènement
Pour indiquer une action à exécuter quand tel évènement a eu lieu, double clic dans la
zone correspondant à l'évènement.
Automatiquement, l'éditeur de code s'ouvre au bon endroit : il suffira ensuite de
compléter le texte de la procédure correspondante.
27
III.5. Les événements les plus importants :
Evènements Explications
OnChange A chaque fois que le contenu change.
OnClick Au moment où on click sur le bouton gauche de la souris.
Au moment où on double click sur le bouton gauche de la

OnDblClick
souris.
OnActivate Quand l’élément est activé.
OnDesactivate Quand l’élément va être désactivé.
OnCreate Quand l’élément est créé.
OnClose A la fermeture de l’élément.
OnDestroy A la destruction de l’élément.
OnHide Au moment où l’élément deviendra caché.
OnShow A l’affichage de l’élément.
OnResize Au redimensionnement de l’élément.
OnKeyPress A la frappe d’une touche de clavier.
OnKeyDown Au moment où la touche du clavier est pressée.
OnKeyUp Au moment où la touche du clavier est relâchée.
OnEnter Au moment ou le curseur focalisera sur l’élément.
OnMouseMove Au moment où le pointeur de la souris touche l’élément.
OnMouseLeave Au moment où le pointeur de la souris quitte l’élément.
OnMouseDown Au moment où la touche de la souris est enfoncée.
OnMouseUp Au moment où la touche de la souris est relâchée.
Tableau 04 : les événements les plus importants
28
III.6. Exemples :
 Exemple1 : Changement de position d'un composant TButton :
• Sur une fiche, dépose un composant de type Tbutton dont tu placeras à la
position 20 pixels du haut de l'écran;
• Active l'onglet Evènements de l'inspecteur d'objets;
• Fais un double clic dans l'événement OnClick;
• Entre les mots begin et end, frappe l'instruction : Button1.Top:= 50;
Lors d'un clic de souris sur le bouton, celui-ci se déplace à la position 50 pixels depuis
le haut de la fiche.
• Fais de même avec une autre grandeur numérique du composant TButton.
 Exemple 2 : Modification d'une valeur de type texte

• Sur une fiche, dépose un composant de type Tbutton dont tu conserveras le nom
et la valeur de Caption;
• Dans l'événement OnClick, indique l'instruction qui permettra de changer la
valeur de Caption:
Button1.Caption:= 'Cliquer ici';
Les informations de type Texte doivent être indiquées entre des

apostrophes en langage Pascal.

 Exemple 3:modifier la couleur d’une fiche
1. insérer les composants suivants de la palette Standard :
Composant Propriété Valeur

Button1 Caption bleu
Button2 Caption rouge
Button3 Caption vert
2. double clique sur le bouton1 (Bleu) et écrire dans la procédure :

Form1.Color:=CLBlue;
Si vous écrivez : (Form1.), Delphi, grâce à son assistant de saisie semi-

automatique, vous propose la liste des membres (propriétés et méthodes)
de la classe saisie (Form1), et on peut soit choisir dans liste la propriété
ou méthode voulue, ou taper les premières lettres de l’élément voulu
(exemple : co pour écrire color) et lorsqu’il sera sélectionné dans la
liste on tape Entrée pour que Delphi l’écrit dans l’instruction.
29
3. taper F12 pour revenir à la fiche et double clique sur le bouton2 (Rouge) et
écrire dans la procédure :
Form1.color:=CLRed;
4. taper F12 pour revenir à la fiche et double clique sur le bouton3 (Vert) et écrire
dans la procédure :
Form1.color:=CLGreen;
5. Lancer l’exécution par la touche F9, ou par le bouton ; Et vérifier le bon

fonctionnement de la fiche.
 Exemple 4 : afficher des fiches à partir d’un bouton

1. Su une fiche, dépose un bouton dont la valeur de caption est « fiche2 »
2. Ajoute une nouvelle fiche dont tu conserveras le nom.
3. Reviens à la 1ere fiche (voir fiche ou Maj+F12), double clic sur le bouton et écris la
ligne de code suivante : form2.show ;
4. Compile et exécute ce programme.
5. Pendant la compilation, le message suivant apparait :
6. Clique sur « Oui » pour terminer l’exécution.
III.7. Exercice théorique :

Répondre à la question suivante :
Pour afficher l'éditeur de code à partir de la fenêtre de l'inspecteur d'objet, il faut :
 Faire un simple clic dans une propriété de l'objet visé
 Faire un simple clic dans un évènement de l'objet visé
 Faire un double clic dans un évènement de l'objet visé
 Frapper la touche F9
30
III.8. Exercice pratique :

Créer une application qui contient trois fiches.
 Fiche 1 dont le titre est « exercices »
 Fiche 2 dont le titre est « exo 1 »
 Fiche 3 dont le titre est « exo 2 »
La 1ere fiche contient 4 bouton comme si indiqué dans l’image suivante :
Boutons
 Message 1 : permet de modifier le contenu du composant « Label 1 » en : « chaque

composant possède : »
 Message 2 : permet de modifier le contenu du « Label 2 » en : « une liste de
propriétés »
 Message 3 : permet de modifier le contenu du composant « Label 3 » en : « une liste
d’événements ».
 Fiche 2: permet d’appeler la fiche 2.
 Fiche 3 : permet d’appeler fiche 3.
 Quitter : permet de quitter le programme.
 Fiche 2 contient un bouton « fermer » et un autre bouton « retour » qui permet de
revenir à la fiche « exercices ».
 Idem pour fiche 3.
Fiche 2 fiche 3
III.9. Résumé :
A l’issu de ce chapitre, on a vu que :

 Chaque composant possède un ensemble de propriétés et d’événements.
 Vous pouvez changer la manière dont un composant s’affiche et se
comporte dans votre application en utilisant l’inspecteur d’objets.
 Lorsqu’un composant est sélectionné sur la fiche, ses propriétés et ses
événements sont affichés dans l’inspecteur d’objets.
31
III.10. Exercices de synthèse :

Durée : 1 h 30mn
But : utilisation des propriétés et des événements des objets
Matériels requis :
 SGBD (Delphi7)
Mise en situation :
1) Etablis une fiche dans laquelle un composant TLabel prend la couleur rouge si
l'on clique sur un bouton et la couleur bleue si l'on clique sur un autre bouton.
• Enregistre le projet dans le sous-répertoire RougeBleu dans ton
répertoire personnel.
2) Etablis une fiche dans laquelle tu placeras un composant TEdit
• Quand on insère un caractère dans le composant TEdit, ce dernier prend
la couleur rouge ;
• Enregistre le projet dans le sous-répertoire Rouge dans ton répertoire
personnel.
3) Etablis une fiche dans laquelle tu placeras un TButton et deux zones TEdit.
Quand on clique sur le bouton, le contenu de la première zone TEdit se recopie
dans la deuxième zone.
• Enregistre le projet dans le sous-répertoire CopieEdit dans ton répertoire
personnel.
4) Etablis une fiche dans laquelle tu placeras deux composants de type TEdit ; le
contenu du deuxième composant doit être automatiquement identique à celui du
premier composant, dès que celui-ci change.
• Enregistre le projet dans le sous-répertoire CloneEdit dans ton répertoire
personnel.
5) Etablis une fiche dans laquelle tu places un composant de type TButton à 100
pixels du bord gauche et un TLabel à proximité; quand la souris se déplace au-
dessus du bouton, celui-ci se déplace à la position 200 pixels du bord gauche.
Quand elle se déplace au-dessus du TLabel, le bouton reprend sa place.
• Enregistre le projet dans le sous-répertoire BoutonFarceur dans ton
répertoire personnel.
Marche à suivre :
 Etape 1 : déposer les composants sur la fiche

 Etape 2 : affectation des propriétés
 Etape 3 : Saisie du code nécessaire
32
Chapitre IV Manipuler les composants les plus utilisés
IV. Manipuler les composants les plus utilisés :

Introduction :
Il existe un nombre considérable de composants et il est hors question de les passer tous
en revue ici, dans ce chapitre, nous citerons seulement les composants les plus utilisés.
IV.1. Les boutons :
Les boutons sont utilisés en général pour proposer à l’utilisateur une action.
Il existe plusieurs types de Boutons :
IV.1.1. Le composant « Button » :

Le bouton standard « Button » est un composant de l’onglet « Standard » de la palette
des composants ; il est généralement utilisé pour poser des choix simples à l’utilisateur
tels que : Oui, Non, Imprimer, Fermer, Quitter...etc
IV.1.2. Le composant « BitBtn » :
 BitBtn (bouton Bitmap) est un composant de l’onglet Supplément de la palette
des composants.
 Il représente un bouton avec une image sur sa face.
 Les boutons bitmap se comportent de la même manière que les composants
bouton.
IV.1.3. Le composant « SpeedButton » :
Il se trouve dans l’onglet « Supplément », à coté du « BitBtn ». Ce bouton fonctionne
selon le même principe que le bouton standard et le BitBtn, il peut contenir des images
et il est généralement utilisé n groupe avec des comportements exclusifs, par exemple :
continuer, reprendre, annuler…
IV.1.4. Les propriétés de chaque composant :
Composant Propriétés
Détermine si le gestionnaire d'événement OnClick
Cancel du bouton doit s'exécuter quand l'utilisateur appuie
sur la touche Echap
Détermine si le gestionnaire d'événement OnClick
Button
Default du bouton doit s'exécuter quand l'utilisateur appuie
sur la touche Entrée.
Détermine si le choix de ce bouton ferme sa fiche
ModalResult
parent (modale) et comment cette fermeture a lieu.
Glyph Détermine le bitmap qui sera dans le bouton.
BitBtn Kind Détermine le type du bouton.
(Ce composant Détermine l'emplacement de l'image dans un bouton
Layout
contient aussi bitmap.
les propriétés Détermine le nombre de pixels entre le côté de
Margin
du composant l'image et le côté du bouton.
TButton(cancel, NumGlyphs Permet d'indiquer le nombre d'image dans le bitmap.
default, Détermine le nombre de pixels entre l'image et le
Spacing
modalresult) texte.
Style Détermine l'aspect du bouton.
Détermine si tous les boutons d'un groupe peuvent
AllowAllUp
SpeedButton être simultanément non sélectionnés.
Down Permet au bouton de rester sélectionner (enfoncé).
33
Flat Détermine si le bouton a une bordure 3D.

Glyph Détermine le bitmap qui sera dans le bouton.
Permet à un certain nombre de bouton de travailler
GroupIndex
en groupe.
Détermine l'emplacement de l'image dans un bouton
Layout
bitmap.
Détermine le nombre de pixels entre le côté de
Margin
l'image et le côté du bouton.
NumGlyphs Permet d'indiquer le nombre d'image dans le bitmap.
Détermine le nombre de pixels entre l'image et le
Spacing
texte.
Transparent Détermine si l'arrière-plan du bouton est transparent.
Tableau 05 : les propriétés du composant Button
 Exemple utilisant la propriété "ModalResult" :
1) Créez deux fiche Form 1, Form 2 comme suit :
Buttons
Form 1
Form 2
2) Ajoutez les événements « Onclick » suivants pour chaque bouton de la fiche

Form 1:
 Button 1 « Cancel=True » :
Form1.Color:=clRed;
 Button 2 «Default=True»:
Form1.Color:=clBlue;
34
 Button 3 «Fiche 2»:

if Form2.ShowModal=mrOK then
Form1.Color:=clGreen;
3) Exécutez
 Exemple montrant les propriétés du composant TBitbtn :
 Exemple montrant les propriétés du composant TSpeedButton :
IV.2. Les barrer d’outils et les barres d’état :
IV.2.1. Les barres d’outils (ToolBar)

Une barre d’outils est une bande qui contient des boutons et d’autres contrôles qui
peuvent remplacer certaines commandes de menus.
Vous pouvez ajouter une barre d’outils à la fiche de plusieurs façons :
 En utilisantle composant ToolBar et en lui ajoutant des contrôles( boutons).
 En plaçant un composant Panel (onglet Standard) sur la fiche et en lui ajoutant
des contrôles.
 En utilisant le composant barre multiple CoolBar et en lui ajoutant des contrôles.
35
Créer une barre d’outils en utilisant le composant « ToolBar » :

 Dans l’onglet Win32 de la palette des composants, cliquez sur le composant
« ToolBar » et déposez-le sur la fiche.
Figure 20 : création d’une barre d’outils
 Cliquez avec le bouton droit de la souris sur le composant ToolBar pour faire
apparaitre le menu contextuel associé.
 Cliquez sur Nouveau bouton pour ajouter un bouton, et sur Nouveau
séparateur pour ajouter un séparateur (facultatif).
La barre d’outils aura la forme suivante :
ToolButton
 Pour ajouter des images aux boutons de la barre d’outils, déposez un composant
ImageList (onglet Win32).
 Double-cliquez sur le composant ImageList, une boite de dialogue s’affiche
(fig20).
Figure 21 : boite de dialogue ImageList
36
 Cliquez sur le bouton Ajouter pour insérer des images (vous pouvez utiliser les
images du répertoire : Program Files\Common Files\Borland
Shared\Images\Buttons.
 Pour insérer les images chargées, modifier la valeur de la propriété « Images »
du composant « ToolBar » en lui affectant la valeur ImageList1.
IV.2.2. La Barre d’état Status Bar :

Le composant « StatusBar » est un composant de l’onglet Win32, il permet de créer une
ligne d’état qui s’aligne, par défaut, sur le bord inférieur de la fiche.
Barre
d’état
Figure 22 : création d’une barre d’état
IV.3. Les zones d’édition :
IV.3.1. Le composant « Edit » :

Le composant Edit permet de proposer une zone d’édition.
Ce composant, qui appartient à l’onglet standard, est une zone de saisie dans laquelle
l’utilisateur doit entrer une donnée à la demande du programme.
IV.3.2. Le composant « MaskEdit » :

MaskEdit est un composant de l’onglet Supplément, c’est une sorte de TEdit auquel est
associé un masque de saisie pour contrôler la validité du texte saisi.
Figure 23 : les zones d’édition
37
IV.3.3. Les propriétés de chaque composant :

En plus des propriétés Name, Width, Height, Left, Hint, ShowHint, Color, Font,visible,
AutoSize, Enabled, Edit et MaskEdit possèdent des propriétés spécifiques :
Composant Propriétés
Contient le texte entré dans la zone d’édition. C’est aussi
Text en modifiant cette propriété que l’on fixe le contenu de la
zone
Spécifie le nombre maximum de caractères que l'utilisateur
MaxLength peut entrer dans la zone Edit. Mettre 0 pour ne pas donner
Edit de limite (par défaut)
À utiliser lorsqu’on veut masquer les caractères tapés,
comme pour les mots de Passe. Utiliser par exemple le
PasswordChar caractère « * » pour masquer, et le caractère « #0 » pour ne
pas masquer.
Text Contenu du texte disponible à l’écran.
MaskEdit Masque de saisie permettant de préciser des règles quant à
EditMask la place de certains caractères obligatoires, des règles de
saisie en majuscules et en minuscules
Tableau 06 : propriétés des zones d’édition
IV.4. Les fonctions de conversion :

Les données inscrites dans les boîtes d’édition sont de type texte (string). Nous devons
donc les transformer afin de pouvoir effectuer des calculs.
Voici quelques fonctions permettant d’effectuer certaines conversions :
IV.4.1. La fonction StrToInt :
Permet de convertir une chaîne de caractères en un nombre entier (type integer).
IV.4.2. StrToFloat(string) :
Convertit une chaîne de caractères en un nombre réel (type real).
IV.4.3. La fonction IntToStr :
Permet d'afficher un nombre entier dans une chaîne de caractères.
Pour comprendre, essayons ces deux exemples :
 Exemple : calculer la somme et la moyenne de deux nombre
 Déposez quatre composants Edit et deux boutons sur une fiche.
38
 Double cliquez sur le bouton « SOMME » puis écrivez la ligne du code

suivante :
Edit3.text :=edit1.text+edit2.text ;
 Double cliquez sur le bouton « MOYENNE » puis écrivez la ligne du code

suivante :
edit4.text:= floattostr ((strtofloat (edit1.text) + strtofloat (edit2.text))/3);
 Exécutez et introduisez deux nombres (12 et 8 par exemple) dans Edit1 et Edit2.
 Vous allez remarquez que la somme est de :
 Vous allez remarquez que la moyenne est de :
Pour régler le problème, rectifiez la ligne du code comme suit :
edit3.Text:=inttostr(strtoint(edit1.Text)+strtoint(edit2.Text));
 Exécutez et le problème est réglé, le résultat maintenant est le suivant :
IV.4.4. La fonction StrToDate :
Function StrToDate(const S: string): TDateTime;

Cette fonction permet de convertir une chaine de caractères en une date.
 Exemple : dans cet exemple, on doit afficher le jour correspondant à une date
donnée.
 Lancez Delphi
 Placez un composant Edit et un Bouton sur la fiche « form1 »
39
 Double cliquez sur le bouton et completez la procédure par les lignes du

code suivantes :
procedure TForm1.Button1Click(Sender: TObject);
var
ADate: TDateTime;
days: array[1..7] of string;
begin
days[1] := 'Dimanche';
days[2] := 'Lundi';
days[3] := 'Mardi';
days[4] := 'Mercredi';
days[5] := 'Jeudi';
days[6] := 'Vendredi';
days[7] := 'Samedi';
ADate := StrToDate(Edit1.Text);
ShowMessage(Edit1.Text + ' est un ' + days[SysUtils.DayOfWeek(ADate)]);
end;
 Exécutez
 Ici, si l’utilisateur entre la date 12/02/2017 par exemple, puis clique sur le
bouton, le résultat sera le suivant :
IV.5. Les fonctions Length et compare texte

IV.5.1. La fonction Length :
Cette fonction Renvoie la longueur de la chaîne de caractères.
 Exemple d’utilisation :
 Lancez un nouveau projet Delphi
 Placez un composant Edit, un label et un Bouton sur la fiche « form1 »
 Double cliquez sur le bouton et insérez les lignes de code suivantes :
label1.Caption:=inttostr(length(edit1.text));
 Exécutez
 Entre une chaine de caractère dans la zone d’édition puis cliquez sur le
bouton.
 Le nombre de caractère sera affiché dans « label1 ».
40
IV.5.2. La fonction comparetext :

Comparaison, sans tenir compte des majuscules/minuscules, de deux chaines de
caractères.
 Lancez un nouveau projet Delphi
 Placez trois composants Edit, et un Bouton sur la fiche « form1 »
 Double cliquez sur le bouton et insérez les lignes de code suivantes :
edit3.Text:= inttostr(comparetext(edit1.Text,edit2.Text));
 Exécutez
 Entre deux chaines de caractère dans les deux zones d’édition puis cliquez
sur le bouton.
 La différence sera affichée dans la 3eme zone d’édition.
IV.6. Les groupes et les listes :

IV.6.1. La case à cocher :
La case à cocher « CheckBox » est un composant de l’onglet Standard qui donne à
l’utilisateur la possibilité de choisir parmi plusieurs possibilités.
Le contrôle CheckBox est composé d'une case à cocher et de son texte descriptif. Voici
une case à cocher :
Figure 24 : composant CheckBox
41
IV.6.1.1. Utilisation :
La Case à cocher propose une option que l'utilisateur peut faire passer de Oui à Non ou
de Vrai à Faux. Les cases à cocher peuvent servir à afficher un groupe de choix qui ne
sont pas mutuellement exclusifs. Les utilisateurs peuvent sélectionner plusieurs cases à
cocher dans un groupe.
 Exemple :
Figure 25 : exemple d’utilisation du composant CheckBox
IV.6.1.2. Les propriétés les plus importantes:

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.
IV.6.1.3. Evénements liés à CheckBox :

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.
IV.6.2. Les cases d’option :
 Le composant RadioBouton :
Le composant "RadioButton", (onglet Standard), permet de proposer un choix à
l'utilisateur parmi plusieurs possibilités. Chaque possibilité est constituée d'un
composant "RadioButton". A l'intérieur d'un composant conteneur ou d'une fiche,
l'utilisateur ne peut cocher qu'un seul composant "RadioButton", quelque soit le nombre
proposé.
42
Figure 26 : composant RadioButton
 Le composant GroupBox :
Le composant GroupBox représente une boite groupe standard utilisée pour regrouper
des composants associés d’une fiche.
Quand un autre composant est placé à l’intérieur du GroupeBox, ce dernier devient le
parent de ce composant.
Lorsque l'on veut proposer à l'utilisateur le choix parmi plusieurs options, un composant
GroupBox contenant des composants RadioButton est un bon choix.
Les composants "GroupBox" ont pour but d'effectuer des regroupements visibles de
composants.
Pour créer des groupes de composants séparés, il faut les regrouper dans des contrôles
conteneurs comme les "Panel" ou les "GroupBox".
Figure 27 : exemple d’utilisation du composant GroupBox
43
IV.6.2.2. Les propriétés les plus importantes:

Idem pour le composant CheckBox, le RadioButton possède les propriétés suivantes :
Caption : Permet de spécifier le texte qui apparait à coté de la case d'option..
Checked : Permet de connaître ou de modifier l'état de la case : cochée ou pas.
IV.6.2.3. Evénements liés au RadioButton :

OnClick : Déclenché lorsque l'état de la case d'option 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.
IV.6.3. Le composant ListBox :

Ce composant, de l’onglet Standard, nous permet d’utiliser des listes dans nos fiches
C’est une extension de Edit à plusieurs lignes, qui permet d'afficher une liste d'éléments,
parmi lesquels l'utilisateur peut choisir un ou plusieurs éléments (plusieurs choix sont
possibles à ce niveau). Chaque élément est présent sur une ligne.
Le composant ListBox permet d’afficher une liste déroulante d’éléments où l’utilisateur
peut sélectionner, ajouter ou supprimer des éléments. Ce composant peut être aussi
utilisé pour afficher une liste de résultat.
Il est possible de sélectionner un ou plusieurs éléments (mais pas d’édition).
Figure 28 : exemple d’utilisation du composant ListBox

IV.6.3.2. Les propriétés les plus importantes :
Items : permet la gestion des éléments. Cette propriété dispose d'une
propriété tableau par défaut pour accéder aux éléments. Ces
éléments sont de type chaîne de caractère.
ExtendedSelect : Lorsque MultiSelect vaut True, ExtendedSelect permet une sélection
d'éléments non à la suite les uns des autres. Lorsque ExtendedSelect
vaut False, seule une plage contigüe d'éléments peut être
sélectionnée : d'un élément de départ à un élément de fin. Dans le
cas contraire, n'importe quel élément peut être sélectionné ou non.
IntegralHeight : Permet ou interdit l'affichage d'éléments coupés, c'est-à-dire
d'éléments partiellement visibles. Lorsque IntegralHeight vaut False,
44
ces éléments sont affichés. Dans le cas contraire, la hauteur de la

zone de liste est ajustée pour afficher un nombre entier d'éléments.
ItemHeight : Permet de fixer la hauteur d'un élément. Cette valeur est calculée
automatiquement lorsque vous changez la police utilisée par la zone
d'édition.
MultiSelect : Permet de sélectionner plusieurs éléments. Lorsque MultiSelect est
faux, un élément au plus est sélectionné. Dans le cas contraire,
plusieurs éléments sont sélectionnables. Les possibilités de sélection
dépendant de la valeur de ExtendedSelect.
Sorted : Lorsque Sorted vaut True, les éléments de la liste sont
automatiquement triés et insérés par ordre alphabétique. Cette
fonction est parfois très pratique bien que nous préférerons souvent
utiliser nos propres tris ou ne pas trier (fixer Sorted à False).
Style : Fixe le style de la zone de liste. Pour l'instant, laissez la valeur de
Style à lbStandard. Plus tard, si vous le souhaitez, vous pourrez en
utilisant les autres valeurs dessiner vous-mêmes les éléments de la
zone et créer ainsi des listes personnalisées visuellement.
IV.6.3.3. Les Propriétés : ItemIndex, SelCount, Selected

ItemIndex :
La propriété ItemIndex indique le numéro d'ordre de l'élément sélectionné dans la liste.
ItemIndex est utilisé aussi bien pour sélectionner un élément de la liste, que pour
connaître le numéro de l'élément sélectionné au moment du fonctionnement du
programme.
 Exemple :
 Mettre, sur une fiche, un composant ListBox, un bouton et un label.
 Passer à la propriété « Items » du ListBox et insérer des valeurs
(A,B,C ,D…par ex).
 Double cliquer sur le bouton et insérer la ligne du code suivante :
Label1.Caption:=listbox1.Items[listbox1.ItemIndex];
 Exécuter
 Sélectionner un élément de la liste puis cliquer sur le bouton, vous allez
remarquez que cet élément sera affiché dans le label.
Figure 29: propriété ItemIndex, exemple d'utilisation
45
Selcount :
La propriété SelCount permet de connaître le nombre d'éléments sélectionnés dans la
liste, si la propriété MultiSelect est vraie. Cette propriété est consultable, mais n'est pas
modifiable. Lorsque la propriété MultiSelect et fausse, la propriété SelCount vaut
toujours -1.
 Exemple :
 Prenez le même exemple précédent.
 Mettez la propriété « MultiSelect » à True.
 Ajoutez un autre bouton, cliquez dessus et écrivez la ligne suivante :
Label1.Caption:=IntToStr(Listbox2.SelCount);
 Exécutez.
 Utilisez Ctrl+Clic pour sélectionner quelques éléments puis cliquez sur le
bouton.
 Voici le résultat, le nombre des éléments sélectionnés sera affiché dans le label.
Figure 30 : propriété ItemIndex, exemple d'utilisation

Selected :
La propriété Selected permet de déterminer ou de connaître quels éléments de la liste
sont sélectionnés. Il s'agit en fait d'un tableau de valeurs booléennes.
Cette propriété est très utile lorsque, par exemple, un traitement doit être appliqué
uniquement aux éléments sélectionnés d'une liste.
 Exemple:
 Sur une fiche, déposer un composant ListBox, un bouton et un label.
 Double cliquer sur le bouton puis insérer le code suivant
procedure TForm1.Button1Click(Sender: TObject);
Var i:integer;
begin
Label1.Caption:=''; //Efface le contenu du label
for i := 0 to (ListBox1.Items.Count-1) do //Boucle pour tous les éléments
begin
if ListBox1.Selected[i]=True then //Vérifie que l'élément i à été
sélectionnée
begin
46
if Label1.Caption='' then
Label1.Caption:=ListBox1.Items.Strings[i]
else
Label1.Caption:=Label1.Caption+''+ListBox1.Items.Strings[i];
end;
end;
end;
 Exécuter, puis cliquer sur le bouton
 Voici le résultat.
Figure 31 : propriété Selected, exemple d'utilisation
IV.6.3.4. Evénements liés à ListBox:

OnClick : Se produit lorsqu'un clic se produit dans la liste.
IV.6.3.5. Insérer des articles per programme : Clear, Add, Delete

Clear :
Permet d'effacer toute la liste
Add :
Permet d’ajouter un élément à la
liste
Delete :
Permet d'effacer l'élément de
rang i de la liste. La liste
commence au rang 0.
 Exemple :
Sur une fiche, insérer les
composants suivant :
Figure 32: méthodes du ListBox
47
 Double cliquer sur le bouton « DELETE » et compléter la procédure comme

suit :
var i: integer;
begin
if ListBox1.SelCount > 0 then
begin
For i := ListBox1.Items.Count - 1 downto 0 do
if ListBox1.Selected [i] then
ListBox1.Items.Delete (i);
end
else
begin
ShowMessage('Please select an item first!');
end;
 Double cliquer sur le bouton « CLEAR » et compléter la procédure comme suit :
ListBox1.Clear;
 Double cliquer sur le bouton « ADD » et compléter la procédure comme suit :
ListBox1.Items.Add(edit1.text);
if CheckBox1.Checked = True then
ListBox1.TopIndex := -1 + ListBox1.Items.Count;
 Exécuter
 Le bouton « CLEAR » supprime toute la liste
 Le bouton « DELETE » supprime un élément sélectionné.
 Le bouton « ADD » ajoute l’élément saisi dans la zone d’édition (Edit1) à la
liste si la case a cocher est cochée.
IV.6.4. La boite combo « ComboBox » :

Un composant ComboBox est une boîte de saisie associée à une liste déroulante. Les
utilisateurs peuvent sélectionner un élément de la liste ou entrer directement une valeur
dans la boîte de saisie.
48
Le composant "ComboBox" est une zone de liste
déroulante qui permet la gestion d’une liste d’éléments.
Contrairement à une ListBox, un ComboBox ne permet
la sélection que d'un élément à la fois. L’élément
sélectionné est placé dans la zone d’édition du
ComboBox.
Figure 33 : exemple
d’utilisation d’un
ComboBox
Items : Utiliser cette propriété pour accéder à la liste d'éléments apparaissant dans
la liste de la boîte à options.
Text : L’élément sélectionné dans le ComboBox sera placé dans cette propriété
Style : Détermine le style de la zone de liste déroulante.
IV.6.4.3. Evénements liés à ComboBox :
OnChange : Lorsque le composant comporte une zone d'édition, celle-ci déclenche

des événements OnChange comme une zone d'édition normale. Ces
événements vous permettent d'exécuter du code répondant à tout
changement.
OnClick : Déclenché lors d'un clic sur toute partie du composant, que ce soit la
liste déroulante ou la zone d'édition.
IV.6.4.4. Insérer des articles per programme : Clear, Add, Delete:

Clear :
Permet d'effacer tous les éléments du ComboBox.
Add :
Permet d’ajouter un élément au Combobox.
Delete :
Permet d'effacer l'élément du Combobox.
 Exemple :
 Prenez le même exemple précédent (concernant le composant ListBox).
 Remplacez ListBox1 par Combobox1.
 Introduisez les lignes du code suivantes :
49
combobox1.Items.Add(edtitem.text);
var i: integer;
begin
For i := comboBox1.Items.Count - 1 downto 0 do
combobox1.Items.Delete (combobox1.ItemIndex);
end;
combobox1.Clear;
 Exécuter pour tester le bon fonctionnement.
IV.7. Les zones d’affichage (Panel,Label, Bevel) :
IV.7.1. Le composant « Label » :

Un Label est un composant qui nous permet d’utiliser des étiquettes dans nos fiches
Les Labels sont utilisés pour contenir des titres ou des descriptions.
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.
Figure 34 : exemple d’utilisation d’un Label
50

Alignment : Permet d'aligner le texte à droite, au centre ou à gauche. N'est utile
que lorsque "AutoSize" est faux et qu'une taille différente de celle
proposée a été choisie. Le texte s'aligne alors correctement.
AutoSize : Active ou désactive le redimensionnement automatique du Label.
"true" ne permet qu'une seule ligne, avec une taille ajustée au texte
présent dans le label, tandis que "false" permet plusieurs lignes,
non ajustées au contenu du label.
Caption : Permet de spécifier le texte à afficher dans le label.
FocusControl : Référence à un autre contrôle.
Cette propriété permet de choisir le composant qui reçoit le focus
(qui est activé) lorsqu'on clique sur le label. Cette propriété permet
un certain confort à l'utilisateur puisqu'un clic sur une étiquette
pourra par exemple activer le composant étiquetté.
Layout : Alter-ego vertical de "Alignment".
Visible : Permet de montrer ou de cacher le label. Cette propriété fait partie
des grands classiques qui ne seront plus repris dans la suite.
WordWrap : Autorise les retours à la ligne pour permettre d'afficher plusieurs
lignes à l'intérieur du label. "AutoSize" doit être faux pour
permettre l'utilisation de plusieurs lignes.
IV.7.2. Le composant « Panel » :

Un composant Label a le même rôle qu’un Label, c'est-à-dire qu’il permet de contenir
du texte. Il possède deux caractéristiques : il peut contenir d’autres composants et il peut
être aligné.
Les composants "Panel", ou panneaux, sont fréquemment employés sous Delphi. Ils ont
deux rôles connus, que l'on peut parfois combiner. L'intérêt de ces panneaux, c'est que
ce sont des conteneurs, qu'ils possèdent une bordure 3D configurable à volonté, et qu'ils
sont alignables. Cette dernière caractéristique, si elle n'évoque probablement pas grand
chose pour vous, sera bientôt une aide précieuse dans la conception de vos interfaces.
Les panneaux sont donc utilisés soit pour leurs bordures 3D, soit pour créer des
alignements.
Panel
Figure 35 : exemple d’utilisation d’un Panel
51

Align : Décide de l'alignement du panneau :
• alNone : aucun alignement.
• alLeft : alignement sur la gauche du conteneur. Seule la
bordure droite du panneau est libre.
• alRight : alignement sur la droite du conteneur. Seule la
bordure gauche du panneau est libre.
• alTop : alignement en haut du conteneur. Seule la bordure
inférieure du panneau est libre.
• alBottom : alignement en haut du conteneur. Seule la
bordure supérieure du panneau est libre.
• alClient : alignement sur toute la partie non recouverte par
d'autres composants alignés. Aucune bordure n'est libre.
BevelInner : Type de bordure intérieure. Vous avez le choix entre bvLowered

(effet abaissé), bvNone (pas d'effet), bvRaised (effet relevé) et
bvSpace (espacement)..
BevelOuter : Item avec la bordure extérieure. Combinez les deux bordures pour
obtenir un cadre à effet relevé ou enfoncé.
BevelWidth : Largeur des bordures intérieures et extérieures en pixels. Evitez de

fixer une valeur supérieure à 3 pixels.
BorderWidth : Spécifie l'espacement entre la bordure intérieure et la bordure

extérieure. Essayez de ne pas dépasser quelques pixels.
Caption : Spécifie le texte qui apparaît à l'intérieur du panneau. Lorsque le

panneau est utilisé pour créer des alignements, il faut penser à
effacer le contenu de Caption.
IV.7.3. Le composant « Bevel » :

Le composant Bevel (onglet Supplément) a un but simple : il est décoratif. En effet, ce
composant ne sert qu'à créer des effets visuels à l'aide de ses quelques propriétés
permettant de créer des bordures 3D. Vous pouvez ainsi créer un cadre, ou seulement
l'un des cotés du cadre, et changer l'effet graphique du composant. Ce composant, moins
performant que Panel dans le sens ou il n'est pas un conteneur et offre un peu moins de
possibilités de bordures, permet cependant de se passer d'un Panel de temps en temps.
52
Bevel
Figure 36 : exemple d’utilisation d’un Bevel

Shape : Détermine l'effet visuel créé par le Bevel (dépendant également de la
propriété Style :
• bsBox : affiche le contenu du Bevel comme relevé ou enfoncé.
• bsFrame : affiche un cadre relevé ou enfoncé autour du contenu.
• bsTopLine : affiche uniquement la ligne supérieure du cadre.
• bsBottomLine : affiche uniquement la ligne inférieure du cadre.
• bsLeftLine : affiche uniquement la ligne gauche du cadre.
• bsRightLine : affiche uniquement la ligne droite du cadre.
Style : Fixe le style de bordure du cadre : bsLowered (enfoncé) ou bsRaised
(relevé).
Exemples d’application :
 Exemple1 :
On souhaite réaliser l’application suivante :
 L’application se compose de 2 fenêtres : « Application » et « Calculs » comme
si indiqué ci-dessous :
53
 Lorsque l’utilisateur clique sur le radio bouton « Informations », le message

suivant s’affiche : « Apprendre à manipuler les composants de base », lorsqu’il
clique sur « ok », la boite de message se referme.
 Lorsque l’utilisateur clique sur la radio bouton « Calculs », la fenêtre « Calculs »
s’ouvre.
 L’utilisateur saisit alors un
nombre, puis clique sur les
CheckBox de son choix.
 Cette fenêtre possède également
deux boutons dans un Panel :
Précédent pour revenir à la
fenêtre « Application », et
Quitter pour quitter l’application.
Réalisation :
 Démarrez Delphi, un nouveau projet s’ouvre par défaut.
 Réalisez première fiche : un Label et trois RadioButton.
 Affectez le nom « principale » et le caption « Application » à cette fiche.
 Affectez les noms « info », « calc » et « quit » aux trois RadioButton.
 Ajouter une nouvelle fiche et lui affectez le nom « resultat » et caption
« Calculs ».
 Déposez un Label, 4 Edit, 3 CheckBox et deux boutons sur un Panel.
 En registrez les deux unités unit1, unit2 et le projet.
54
Nous allons maintenant écrire le code source du projet :

 Affichez la 1ere fiche « principale » (Voir/Fiches).
 Double cliquez sur le radioButton Informations puis introduisez le code
suivant entre le beginet le end :
showmessage('Apprendre à manipuler les composants de base');
 Appuyez sur la touche F12 pour revenir à la fiche ;

 Double-cliquez sur le RadioButton « Calc » et complétez la procédure par le
code suivant : resultat.show;
 Double-cliquez sur le RadioButton « Quit » et complétez la procédure par le
code suivant : Application.Terminate ;
 Affichez la 2eme fiche « resultat ».
 Double-cliquez sur le CheckBox « Double » et complétez la procédure par le
code suivant :
edit2.Text:=inttostr(strtoint(edit1.Text)*2);
 Double-cliquez sur le CheckBox « Triple » et complétez la procédure par le
code suivant :
edit3.Text:=inttostr(strtoint(edit1.Text)*3);
 Double-cliquez sur le CheckBox « Carré » et complétez la procédure par le
code suivant :
edit4.Text:=inttostr(strtoint(edit1.Text)*strtoint(edit1.Text));
 Double-cliquez sur le bouton « précédent » et complétez la procédure par le
code suivant : principale.show ;
 Double-cliquez sur le bouton « Quitter » et complétez la procédure par le
code suivant : Application.Terminate ;
 Enregistrez et exécutez l’application ; pendant l’exécution, la fenêtre
suivante s’affiche :
 Cliquez sur « Oui » et continuez l’exécution.
55
 Si vous entrez par exemple le nombre 6, voici le résultat que vous allez
obtenir :
 Exemple2 :
Interface :
Dans cet exemple, la couleur de la fiche sera modifiée une fois en utilisant les Boutons
Radio, et une autre fois en utilisant le ComboBox.
Voici les étapes d’exécution ;

1. Lancez Delphi, dans la fiche « form1 » par défaut, déposez les composants
suivants :
 Un Label dont le caption est : « choisir la couleur de la fiche ».
 Un Panel qui contient trois RadioButton (Bleu, Rouge, Vert).
 Un autre Panel qui contient un composant ComboBox
 Cliquez sur la propriété « items » du ComboBox et écrivez les
éléments de la liste (Bleu, Rouge,vert).
2. double clique sur le Radiobutton1 (Bleu) et écrire dans la procédure :
Form1.color:=clblue;
56
3. Taper F12 et double clique sur le Radiobutton2 (Rouge) et écrire dans la

procédure :
Form1.color:=clred;
4. Taper F12 et double clique sur le Radiobutton3 (Vert) et écrire dans la
procédure :
Form1.color:=clgreen;
5. Double clique sur le Combobox1 et écrire dans la procédure (attention au
lettres majuscules):
If combobox1.text=’Bleu’ then
form1.color:=clblue;
if combobox1.text=’Rouge’ then
form1.color:=clred;
if combobox1.text=’Vert’ then
form1.color:=clgreen;
6. Lancer l’exécution.
IV.8. Exercices pratiques :

Exercice 1 :
Dans cet exercice, on va réaliser
l’application suivante :
1. Créer une application qui
contient la fiche suivante :
2. Lorsque l’utilisateur clique

sur un RadioButton,
l’opération choisie sera
effectué.
57
Exercice 2 :
Ecrire un programme qui comporte un Edit, un bouton, et un ListBox. L'utilisateur tape
un texte dans l'Edit. Lorsqu'il clique sur le bouton, le texte est ajouté dans le ListBox et
l'Edit est vidé.
IV.9. Résumé :
Ce long chapitre est terminé et vous a montré :

 Quels sont les composants les plus utilisés sous Delphi tels que : les
Boutons, les barres, les zones d’édition et d’affichage, les groupes et
listes.
 Que tous ces composants sont organisés sous forme de pages (onglets)
dans la palette des composants, selon leurs fonctions.
 Vous avez également appris ce que seront concrètement les composants
utilisées dans vos applications Bases de Données, tels que les objets
situés dans les pages Standard, AccèsBD, ContrôleBD et BDE.
58
IV.10. Exercice de synthèse :

Durée : 2h
But : manipulation des composants les plus utilisé
Matériels requis :
 SGBD (Delphi7)
Mise en situation :
Cet exercice vise à réaliser l’application tp 2 suivante :

 L’application contient trois fiches:
BitBtns ToolBar
La fiche principale
La fiche « couleurs »
59
La fiche « calculs »
 Dans la fiche principale, le bouton « couleur » permet d’afficher la Fiche

« couleurs ».
 Le bouton « calculer » permet d’afficher la fiche « calculs ».
 Le bouton « A propos » permet d’afficher une boite qui contient le message
suivant :
 Le bouton « quitter » permet de quitter l’application.

 Dans la fiche « couleurs », les trois radio bouton permettent de modifier la
couleur de la page.
 Le bouton « Fermer » permet de fermer la fiche « couleurs »
 Dans la fiche « calculs », les CheckBox permettent d’effectuer le calcul su le
nombre sélectionné dans le combobox.
Marche à suivre :
 Etape 1 : créer les fiches

 Etape 2 : déposer les composants sur les fiches
 Etape 4 : écriture des lignes de code
60
Chapitre V Manipuler les composants non visibles à l’exécution et les messages
V. Manipuler les composants non visibles à l’exécution et les messages:

Introduction :
Les boites de dialogues communes et les messages, qu’on va voir dans ce chapitre, sont
des outils normalisés Windows.
Toutes les sources les utilisent car elles sont faciles à programmer et elles donnent un
aspect standard. Toutes les boites de dialogues communes sont dans la palette de
composants dans l'onglet Dialogues.
V.1. Les composants non visibles à l’exécution « boites de dialogues »:
V.1.1. Le composant « Timer » :
Ce composant fait partie des objets Système.
Ce n'est pas un objet graphique, il apparaît sur la fiche comme une petite horloge mais
ne figurera pas dans la présentation finale à l’écran.
Timer est un compteur interne qui délivre à des intervalles réguliers un signal
déclenchant une action choisie par le programmeur. Il permet de lancer régulièrement
une tache.
 Exemple1 :
1- insérer un composant Timer (palette système)

2- insérer deux composants Label (palette
standard)
3- double clique sur le composant Timer1 et
écrire dans la procédure :
Label1.caption :=timetostr(time) ;
Label2.caption :=datetostr(date) ;
4- Lancer l’exécution par la touche F9, ou par le bouton ; Et vérifier le bon

fonctionnement de la fiche.
5- voici le résultat qu’on doit obtenir.
Figure 37 : exemple d’utilisation d’un Timer
61
 Exemple2 :
• Démarre une nouvelle application.
• Sur la fiche vierge, dépose :
o un composant de type TTimer;
o un composant de type TButton;
o un composant de type TLabel.
La position du composant de type "Timer" sur la fiche est sans importance. On ne le

verra pas durant l'exécution du programme: c'est un composant non visuel.
• Affecte la valeur false à la propriété Enabled du composant Timer. Il est donc
désactivé.
• Affecte la valeur 3000 à la propriété Interval. Il va donc se passer 3000
millisecondes, c.à.d. 3 secondes avant le déclenchement de l'événement.
• A l'événement OnTimer, affecte la procédure qui permet de passer le

composant TLabel en couleur rouge
Label1.color :=clred ;
• A l'événement OnClick du bouton, affecte la procédure qui remet la

propriété Enabled à la valeur True.
timer1.Enabled:=true;
Que se passe-t-il lors de l'exécution de cette application?

1. Un clic sur le bouton provoque le démarrage du
composant "Timer".
2. Lorsque le temps prévu est écoulé, le composant
"Timer" provoque l'exécution de la procédure
prévue: le changement de couleur du composant
TLabel.
Nous assistons donc une cascade de deux événements.
V.1.1.1. Propriétés et événements :

Enabled : Si True (vrai) le compteur interne est lancé sinon il est inhibé.
Intervalle : C'est en millisecondes le temps qui s'écoule entre deux événements

déclenchés
 Le seul événement proposé est OnTimer, c'est l’impulsion déclenchante citée

plus haut.
62
V.1.2. Le composant OpenDialog :

Ce composant est utilisé pour afficher la boite de dialogue standard d’ouverture d’un
fichier.
La propriété « filename » donne le nom et l’emplacement du fichier ouvré.
 Exemple d’utilisation :
Placez, sur une fiche, un bouton, un Edit et un
OpenDialog comme c’est montré dans l’image
ci-contre :
 Double cliquez sur le bouton et insérez

la ligne du code suivante :
if OpenDialog1.Execute then
edit1.Text:= OpenDialog1.FileName;
 Exécutez
 En cliquant sur le bouton, la boite
de dialogue « Ouvrir » s’affiche,
et une fois que vous sélectionnez
un fichier, son nom et son chemin
seront affiché dans la zone Edit1.
Figure 38: OpenDialog, exemple d'utilisation
V.1.3. Le composant SaveDialog :

Ce composant ouvre la boite de dialogue 'Sauvegarder'
Vous trouverez un ci-dessous exemple d’utilisation
V.1.3.1. Les propriétés les plus importantes :
Les deux composants que l'on a évoqué ci-dessus, (OpenDialog et SaveDialog)
proposent exactement les mêmes propriétés.
Propriété Description
Spécifie l'extension devant être ajoutée au nom du fichier saisi par
DefaultExt
l'utilisateur, s'il l'omet.
Indique si l'utilisateur peut saisir un nom de fichier ou doit choisir un
FileEditStyle
fichier proposé dans une boîte à options.
FileName Nom du fichier saisi ou sélectionner.
Files Liste des fichiers sélectionnés.
63
Filter Détermine le ou les filtres que peut utiliser l'utilisateur.

FilterIndex Indice du filtre devant être actif parmi ceux définis.
HistoryList Liste des fichiers pouvant être sélectionné.
InitialDir Indique le répertoire lors de l'ouverture.
Options Détermine l'aspect de la boite.
Tile Titre de la boite de dialogue.
Tableau 06 : propriétés du composant SaveDialog
V.1.4. ColorDialog :
Ce composant ouvre la boite de dialogue 'Couleur'.
Grâce à cette boite de dialogue, on peut choisir une couleur parmi 65536.
Les propriétés les plus importantes :
Color : Couleur sélectionnée.

CustomColor : Tableau contenant les couleurs personnalisées.
Options : Apparence de la boite.
 Exemples d’utilisation :
exemple1 :
 Cliquez sur le bouton et écrivez la

procédure suivante :
Figure 39: exemple d''utilisation d'un

ColorDialog
ColorDialog1.Color:=Panel1.Color;
if ColorDialog1.Execute then
Panel1.Color:=ColorDialog1.Color;
 Exécutez.
Exemple 2 :
64
 Le bouton « Open » : OpenDialog1.Execute ;

 Le bouton « Save » : SaveDialog1.Execute;
 Le bouton « Color » : ColorDialog1.Execute;
 Exécutez.
 Si l’utilisateur clique sur le bouton « Open », la boite de dialogue Ouvrir
s’affiche.
Figure 40 : exemple d’utilisation des boites de dialogue
V.2. Les messages :

Une boite de message est une boite de dialogue contenant une image. Elle est utilisée
pour dialoguer avec l'utilisateur. En Delphi, il est facile de les utiliser.
Delphi propose 2 types de messages de dialogue :
V.2.1. ShowMessage (les messages simples) :
C’est un message d’information
 Exemple :
Voici une capture d'une boite de message.
- L’instruction qui appelle ce message est :

Showmessage(‘bonjour tous le monde’) ;
- on peut insérer un bouton et double clique sur ce
dernier et écrire l’instruction au-dessus. Figure 41: exemple de message
65
V.2.2. MessageDlg (messages avec options) :

La fonction « MessageDlg » permet d’afficher une boîte de dialogue avec un message et
divers boutons.
Boite de dialogue Valeur

Avertissement mtWarning
Confirmation mtConfirmation
Custom mtCustom
Erreur mtError
Information mtInformation
Tableau 07 : Utilisation des boites de message
Ces boites de dialogues contiennent une image différente selon leur valeur :
Valeur Description
Une boîte de message contenant un signe point d'exclamation
mtWarning
jaune.
mtConfirmation Une boîte de message contenant un point d'interrogation vert.
Une boîte de message ne contenant pas d'image. Le titre de la
mtCustom boîte de dialogue est le nom du fichier exécutable de
l'application.
mtError Une boîte de message contenant un signe de stop rouge.
mtInformation Une boîte de message contenant un "i" bleu.
Tableau 08 : types de boites de message
mbYes Un bouton avec le texte "Oui".

mbNo Un bouton avec le texte "Non".
mbOk Un bouton avec le texte "OK".
mbCancel Un bouton avec le texte "Annuler".
mbAbort Un bouton avec le texte "Abandonner".
mbRetry Un bouton avec le texte "Réessayer".
mbIgnore Un bouton avec le texte "Ignorer".
mbAll Un bouton avec le texte "Tous".
mbNoToAll Un bouton avec le texte "Non à tout".
mbYesToAll Un bouton avec le texte "Oui à tout".
mbHelp Un bouton avec le texte "Aide".
Tableau 09 : Les boutons des messages possibles
66
 Exemple d’application:
Cet exemple utilise un bouton sur une fiche.
1. Quand l'utilisateur clique sur le bouton, une boîte de message demandant à
l'utilisateur s'il souhaite quitter l'application apparaît.
2. Si l'utilisateur choisit Oui, une autre boîte de dialogue apparaît pour informer
l'utilisateur que l'application est sur le point de se terminer.
3. Quand l'utilisateur choisit OK, l'application se termine.
Interface :
Double cliquez sur le bouton « QUITTER » puis complétez la procédure:
if MessageDlg('Bienvenue dans mon application, Quitter?',

mtConfirmation, [mbYes, mbNo], 0) = mrYes then
begin
MessageDlg('Fin de l''application', mtInformation,[mbOk], 0);
Close;
end;
MessageDlg('Bienvenue dans mon application, Quitter?', mtConfirmation, [mbYes, mbNo]
Message Le texte du message MT=Message MB=Message

de (Choix libre) Type Button
Dialogue
0 : Numéro du fichier d’aide.( 0 = pas de fichier d’aide)
Figure 42: MessageDlg: exemple d'utilisation
67
V.3. Exercice pratique :

Réalise une application qui contient trois composants de type "Label" et un bouton.
Lorsque l'on clique sur le bouton, les trois composants de type "Label" changent
continuellement de couleur selon le schéma illustré sur l'animation ci-dessous.
V.4. Résumé :
Ceci termine ce chapitre consacré à la manipulation des composants

particuliers comme les composants invisibles ou messages.
Ce chapitre n'est en fait qu'une entrée en matière pour les chapitres suivants.
Vous savez maintenant ce que sont les composants non visibles à l’exécution
Vous savez également la différence entre les deux types de messages :
MessageDlg et Showmessage.
Ce qu'il vous manque maintenant, c'est comment les utiliser pour manipuler
une base de données.
68
V.5. Exercice de synthèse :

Durée : 45 mn
But : Affichage d’une image sur une fenêtre en utilisant les composants Image et
OpenPictureDialog.
Matériels requis :
 SGBD (Delphi7)
Mise en situation :
 Afficher une image sur une fenêtre.
 Lorsqu’on clique sur un bouton, une boite de dialogue s’affiche et permet de
charger une autre image.
 Lorsqu’on clique sur un autre bouton dans la même fenêtre, on quitte
l’application après l’apparition du message de confirmation suivant : « voulez
vous quitter l’application ? ».
 Ce qu’on souhaite obtenir :
Marche à suivre :
 Etape 1 : créer un nouveau projet et l’enregistrer

 Etape2 : déposer les composants sur la fiche
 Etape 4 : saisie du code nécessaire
69
Chapitre VI Créer une application multi fiche avec un menu
VI. Créer une application multi fiche avec un menu :

Introduction :
Pendant l’exécution d’une application, il est possible, sous Windows, de commuter
entre plusieurs fiches et de passer d’une fenêtre à une autre, et ceci par la création d’un
menu principal de l’application. Nous allons donc tout découvrir dans ce chapitre.
VI.1. Main Menu, Image List :
VI.1.1. Editeur de menu:

La mise en place d'une barre de menus est simplifiée par le concepteur de menus.
Le composant MainMenu, de l’onglet Standard, est utilisé pour placer un menu
principal dans une fiche.
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.
Les propriétés importantes du composant "MainMenu" sont décrites ci-dessous :
Images : Référence à un composant "ImageList".

Permet d'associer à un menu une liste d'images stockées dans un
composant "ImageList".
Items : Permet l'accès à l'éditeur de menus.
Voici un exemple d'utilisation de ce composant.
Figure 43 : exemple d’utilisation du MainMenu

VI.1.2. Réaliser une barre de menu :
La barre de menu n'est pas un contrôle, mais un composant dont la représentation
graphique apparaît sous forme d'une icône dans la fiche.
Pour créer une barre de menu, placez sur la fiche un composant de type "TMainMenu".
Double-cliquez sur lui pour accéder au concepteur de menus. Il suffit alors de taper les
noms en validant avec la touche "entrée".
70
Figure 44 : réalisation d’une barre de menu

Pour se déplacer, on peut utiliser la souris ou les flèches de direction.
VI.1.3. Réaliser un sous menu :

Un simple clic droit sur un menu déjà créé permet de créer un sous menu.
Figure 45 : réalisation d’un sous menu

VI.1.4. Affecter une image à une commande du menu :
En Delphi, il est facile d'insérer des bitmaps dans un menu. Cette option est disponible
grâce au composant ImageList.

Le composant ImageList (Liste d’images) est un composant contenant une liste d’icônes
(toutes à priori de la même taille) ; cette liste d’icônes peut alors être associée à un
menu, une barre d’outils… afin d’attribuer une icône à chaque item de menu ou de la
barre d’outils.
Le composant "ImageList" est non visuel. Il permet de stocker une liste d'images de
mêmes dimensions. Il est ensuite utilisable par d'autres composants pour leur permettre
d'accéder directement à la liste d'images. (revoir chapitre IV/manipuler les composant
les plus utilisés/les barres d’outils)
VI.1.5. Créer des raccourcis :
• Pour chaque élément du menu on choisit une lettre et on écrit avant elle
le symbole "&" pour assurer un raccourci clavier :
 Exemple : &Edition  Edition
• Pour choisir un raccourci Clavier quelconque on sélectionne un élément
du menu et dans la propriété ShortCut on choisit le raccourci adéquat.
 Exemple : Ctrl + N pour l’élément « Nouveau » du menu.
71
VI.1.6. Utiliser le soulignement et le séparateur des groupes :

Pour faire une ligne de séparation on écrit dans la propriété "caption" le caractère "-"
Séparateur
Raccourci
clavier
Figure 46: menu séparé
VI.2. Création d’un menu :

VI.2.1. Main Menu, Image List :
Pour créer un menu principal, insérer de la palette Standard le composant Mainmenu1.
VI.2.2. Editeur de menu :

Pour afficher l’éditeur de menu, double cliquez sur le composant Mainmenu1 et écrire
les éléments du menu dans leurs propriétés « caption ».
Figure 47: éditeur de menu

72
VI.2.3. Réaliser un sous menu :

Pour créer un sous menu, cliquez avec le bouton droit de la souris sur une commande du
menu, puis sur Créer un sous-menu.
Figure 48: création des sous menu
VI.2.4. Affecter une image à une commande du menu :

Pour affecter des images à une commande du menu, déposez un composant ImageList
sur la fiche (page Win32).
• double cliquez sur ce composant puis cliquez sur le bouton

• choisissez une ou plusieurs images dans le chemin : « c:\program files\fichiers
communs\borland shared\images\buttons » et cliquez sur Ouvrir.
• le message suivant apparait :
• cliquez sur Oui ou Oui pour tout.

• cliquez sur le composant "Mainmenu1" et choisir ImageList1 dans sa propriété
Images .
• Enfin : double cliquez sur " MainMenu1" et pour chaque élément du menu on
choisit une image par sa propriété ImageIndex.
73
Figure 49:Affectation des images à un menu

VI.2.5. Créer des raccourcis :
 Pour créer un raccourci à une commande par une lettre souligné, il suffit
d’ajouter le symbole & avant la valeur de sa propriété caption.
 Exemple : &Nouveau Nouveau

de cette manière, on peut activer la commande
Nouveau en utilisant la combinaison Alt+N.
 pour ajouter un raccourci clavier à une commande :

• cliquez sur la commande voulue.
• dans la propriété ShortCut vous pouvez
choisir le raccourci adéquat. exemple : Quitter  Ctrl+Q
VI.2.6. Utiliser le soulignement et le séparateur des groupes :

Pour créer une ligne de séparation dans un menu, on remplit la propriété caption de la
commande qui suit par « - ».
Figure 50: séparation d'un menu
74
VI.3. Création de plusieurs fiches :

Pour ajouter d’autres fiches à votre application, vous pouvez utiliser le menu
Fichier/Nouveau/Fiche.
Ou bien cliquez sur l’outil Nouvelle Fiche de la barre d’outils Voir.
VI.4. Création des liens entre les fiches :

Si votre application contient plusieurs fiches, vous devez créer des liens entres ces
fiches, si non, la seul fiche qui va apparaitre à l’exécution est la fiche principale (ou
bien la 1ere fiche créée).
Pour le faire, c’est très simple, une simple ligne de code vous permet d’appeler une
fiche à partir d’une autre.
Supposant qu’on a une application contient 3 fiches : Form1, Form2 et Form3, dans cet
exemple, on va se baser sur le menu créé précédemment.
On va créer les liens suivants :

 Un lien entre la fiche principale Form1 et la fiche Form2 à travers la commande
Nouveau.
 Un lien entre la fiche Form1 et la fiche Form3 à travers la commande Ouvrir.
Pour cela, vous pouvez utiliser deux méthodes :
1ere méthode :
• sur la fiche Form1, activer la barre de menu en cliquant sur Fichier.
• faites un simple clic sur la commande Nouveau.
• écrivez la ligne du code suivante :
form2.show ;
• faites un simple clic sur la commande Ouvrir.
• écrivez le code suivant :
form3.show ;
• exécutez en acceptant les deux messages qui vont apparaitre.
75
2eme méthode :
Cette méthode vous permet d’éviter l’apparition du message précédent.
o avant de commencer à introduire les lignes de code, activer le menu
Fichier de Delphi.
o cliquer sur la commande Utiliser l’unité.
o Dans la fenêtre qui s’affiche, sélectionner Unit2 et Unit3 puis cliquez sur
OK.
o faites maintenant un simple sur la commande Nouveau puis introduisez

la ligne du code.
o vous allez remarquez qu’après la saisie du « . », une liste des choix sera
affiché et vous permet de sélectionnez la procédure souhaitée.
o insérez le code ‘’Form2.show ;’’ pour la commande Ouvrir de la même

manière.
o vous pouvez exécuter maintenant et tester l’application.
76
VI.5. Exercice pratique :

Dans cet exercice, vous allez créer une application « gestemp » composée de deux
fenêtres :
 Une fenêtre principale contenant une barre de menus.
 Une fenêtre d’information contenant des informations, des images et des

boutons.
L’application doit répondre aux événements suivants :

 lorsqu’on clique sur la commande A-Propos, la fenêtre informations s’affiche.
 lorsqu’on clique sur le bouton OK de la fiche informations, celle-ci se ferme.
 les deux commandes Quitter permettent de terminer l’application.
VI.6. Résumé :
C'est déjà la fin de ce chapitre. Vous savez maintenant comment créer une
application multi fiche avec un menu.
Ce chapitre vous a appris comment lier plusieurs fiches et comment basculer entre
elles grâce au composant MainMenu.
77
VI.7. Exercice de synthèse :

Durée : 45 mn
But : créer une application qui contient plusieurs fiches
Matériels requis :
 SGBD (Delphi7)
Mise en situation :
Prenez le même exercice précédent de ce chapitre « gestemp » et lui ajoutez les

modifications suivantes :
 Modifiez le menu principal en lui donnant l’aspect suivant :
 Créez une autre fiche « employe », cette fiche sera affichée à partir de la
commande « NOUVEAU ».
 Ajoutez deux autres fiches
« attestation » et « liste » qui seront
affiché à partir des commandes
suivantes : LISTE DES EMPLYES
et ATTESTATION DE TRAVAIL.
Marche à suivre :
 Etape 1 : lancement du projet

 Etape 2 : création des fiches
 Etape 3 : ajout des titres du menu
 Etape 4 : création des liens entre les fiches.
78
Chapitre VII Concevoir et utiliser des Bases de données
VII. Concevoir et utiliser une base de données :

Introduction :
Delphi permet de gérer les applications de bases de données relationnelles. Ces
dernières organisent les informations en tables, qui contiennent des lignes
(enregistrements) et des colonnes (champs).
Ce chapitre est consacré à quelques rappels sur les bases de données. Par la suite, nous
verrons comment développer et utiliser une application bases de données sous
l’environnement Delphi.
VII.1. Les modules de manipulation des BD :
Une Base De Données (BDD) est un ensemble structuré de données enregistrées sur des
supports accessibles par l’ordinateur.
Les applications de bases de données se composent de trois parties principales :
L’interface utilisateur, un ensemble de composants d’accès aux données et la base
données elle-même.
VII.1.1. Administrateur BDE :

L’administrateur BDE (Borland Database Engine) (moteur de la base de données) permet de
configurer les pilotes BDE et de définir les alias employés par les contrôles pour se
connecter aux bases de données.
L’administrateur BDE se lance à partir du bouton Démarre/ Tous les programmes/
Borland Delphi 7 / Administrateur BDE.
Figure 51: Administrateur BDE
VII.1.2. Module base de données :

Les principaux objets utilisés dans le Module Base de données sont des tables, requêtes
et fichiers SQL. Chaque objet a une extension différente:
Extension Type d'objet
.DB Table Paradox
.DBF Table dBASE
.DBT Mémos pour une table dBASE
.MB Mémos pour une table Paradox
79
.MDX Index maintenu d'une table dBASE

.NDX Index non maintenu d'une table dBASE
.PX Index primaire d'une table Paradox
.QBE Requête sauvegardée
.SQL Fichier SQL sauvegardé
.VAL Contrôles de validité et intégrité référentielle pour
une table Paradox
Tableau 10 : objets utilisés dans le Module Base de données
Deux méthodes pour lancer le module Base de données:

 Lancer Delphi, puis dans le menu Outils choisir la commande Module Base de
données.
 Directement à partir de la liste des programmes installés (Tous les programmes/
Borland Delphi 7 / Module Base de données)
Figure 52 : module Bases de données
VII.2. Créer un alias :

Un alias sera équivalent à un chemin. Par exemple, on peut définir que TEST sera
équivalent à c:\basededonnees\mabase
 Un alias est un chemin d'accès qui servira à stocker les fichiers de la base de
données.
Avant de passer à la création de l’alias, il faut tout d’abords créer un dossier pour
stocker tout ce qui rapporte à la base de données. Par exemple : E:\Gest_stage\BDD.
Pour créer un alias:

 A l’aide de l’Administrateur BDE (Démarrer/Programmes/Borland Delphi 7/
Administrateur BDE)
 Cliquer le menu Objet/ nouveau
 Dans la boite «Nouvel Alias base de données» sélectionner le nom de pilote
base de données (exemple Standard)
80
 Dans le volet «bases de données» taper le nom de L’alias (stagiaire) et lui

associer un chemin sur le disque (E:\Gest_stage\BDD)
 passez par la commande Objet/Appliquer pour enregistrer.
Figure 53: création d'un alias à l'aide de l'administrateur BDE
Ou bien :
 dans le Module Base de données, cliquez sur le menu Outils/ Gestionnaire

d'alias.
 Cliquez sur le bouton "Nouveau" puis entrez le nom (exemple: stagiaire) dans
"Alias de base", "type de pilote" STANDARD et définissez le chemin de la base
(au besoin, cliquez sur "Parcourir"). Notez que le chemin doit être existant.
 Cliquez enfin sur "Provisoire" puis sur "Enregistrer sous" sans rien changer
pour sauvegarder l'alias.
81
Figure 54: création d'un alias à l'aide du module Base de données

VII.3. Créer les tables :
VII.3.1. Nouvelle table :
Pour créer une table depuis le Module Base de données:
 Choisissez Fichier/ Nouveau/ Table
 Le Module Base de données ouvre la boîte de dialogue Création de table, et
propose plusieurs types (paradox, DBase, FoxPro, Informix,Interbase,
MsAccess, Oracle, SyBase) pour la table à créer. Dans ce cours, sélectionner le
type Paradox7puis valider avec OK.
Figure 55(a) Figure 55(b)
 Le Module Base de données ouvre la boîte de dialogue Création de la table

Paradox 7, dans laquelle vous pouvez spécifier la structure de la nouvelle table.
82
Figure 55 (c)
Figure 55 : les étapes de création d’une table

 Pour chaque champ de la table:
1. Spécifier un nom (moins de 25 caractères)
2. Sélectionner un type de champ (Alphanumérique(A), Numérique(N),
Monétaire($), ….)
3. Tapez la taille du champ (si la taille est obligatoire).
4. Si vous le souhaitez, définissez une clé (index) et les propriétés de la
table.
 Lorsque la structure de la table est définie, choisissez Enregistrer sous pour
donner un nom à la table.
Voici les principaux types de champs valides dans Paradox, et les tailles
correspondantes :
Type Symbole Taille Description
Lettres, chiffres,symboles spéciaux
Alphanumérique A 1-255 (tels que %, &, # ou =;d'autres
caractères ASCII imprimables).
Numérique N Nombre réel
Monétaire $ Nombre réel en format monétaire
Entier court S entre -32767 et32767.
Entier long I entre -2147483648 et 2147483647
Date D
Heure T
Date et heure @
pour les chaînes de texte qui sont trop
Mémo M 1-240 longues (longueur virtuellement
illimitée)
Mémo formaté F 0-240 semblables aux champs mémos,
83
excepté que vous pouvez en formater

le texte en ajoutant les attributs de
texte (police, style, couleur et taille)
contient des images (.BMP, .PCX,
Graphique G
.TIF, .GIF et.EPS.)
contient des valeurs représentant
Logique L
l’alternative vrai ou faux (oui ou non)
contient des entiers longsen lecture
seulement (qui ne peuvent pas être
Incrémentation modifiés). Le Module Base de
+
auto données commence par le nombre1 et
ajoute 1 pour chaque enregistrement
de la table.
Tableau 11 : les types des champs

VII.3.1.1. Index d’une table :
 Un index est un fichier qui détermine l'ordre dans lequel le Module Base de
données accède aux enregistrements d'une table. Les index peuvent être des
index primaires ou secondaires.
 Dans les tables Paradox, l'index primaire est aussi appelé clé.
 pour définir un champ comme index, il suffit de taper par la barre d’espace dans
la colonne Index.
 Index primaire :
 En créant un champ clé, vous demandez au Module Base de données de
classer la table dans l'ordre des valeurs de ce champ. Changer de clé change
l'emplacement physique des enregistrements dans la table.
 Une clé doit contenir des valeurs uniques
 Les clés sont obligatoires pour la majorité des liens entre tables et pour
utiliser les contraintes d'intégrité du Module Base de données.
 Les clés sont également utilisées pour accélérer les requêtes et les recherches
dans les tables Paradox.
 Règles pour la définition des champs clé :
 Une table ne peut avoir qu'une clé. Cette clé peut être constituée de un ou
plusieurs champs.
 Les clés ne peuvent être constituées de champs mémos, mémos formatés,
graphiques ni logiques.
 Si une clé est définie par un seul champ, ce champ doit être le premier du
panneau Description des champs.
84
 Si vous désignez plusieurs champs comme clé, vous définissez une clé
composite. Le contenu de ces champs, en tant que groupe, doit être unique
pour chaque enregistrement de la table. La clé composite doit commencer
par le premier champ du panneau Description des champs.
 Exemple :
Clé = Matr
Clé =
Code_mod +
Matr
(Clé
composite)
Index secondaire :
 Un index secondaire est un champ ou un groupe de champs défini comme :
 autre ordre de tri de la table
 Champ permettant de lier la table
 Moyen d'accélérer certaines opérations de recherche
Une table peut avoir plusieurs index secondaires

Vous ne pouvez pas créer d'index secondaire sur les champs mémos,
mémos formatés, graphiques ni logiques
Lorsque vous utilisez un index secondaire, vous ne changez que l'ordre
d'affichage des enregistrements. Leur position physique dans la table ne
change pas.
 Exemple : dans cet exemple, on va définir le champ « non » comme index

secondaire.
85
Figure 56: exemple d'index secondaire

Les propriétés d’une table :
Pour spécifier les propriétés d’une table:
 Afficher la structure de la table
 Sélectionner une propriété de la liste Propriétés de la table
1. Contrôles de validité :
 Les contrôles de validité sont des règles imposées
aux champs; elles garantissent que les données entrées
dans ces champs sont conformes à certaines conditions.
 Le Module Base de données fournit 5types de
contrôles de validité.
86
Contrôle de validité Signification Exemple

Chaque enregistrement de La valeur du champ Nom
Champ obligatoire la table doit contenir une est obligatoire
valeur dans ce champ.
Les valeurs entrées dans ce La valeur minimale du
champ doivent être égales champ Note de la table
Valeur minimum ou supérieures à la valeur Notes est 0
minimale que vous avez
spécifiée ici.
Les valeurs entrées dans ce La valeur Maximale du
champ doivent être champ Note de la table
Valeur Maximum inférieures ou égales à la Notes est 20
valeur maximale que vous
avez spécifiée ici.
Cette valeur remplit La valeur par défaut du
automatiquement ce champ champ Coef de la table
Valeur par défaut
si vous n'y entrez pas Modules est 1
d'autre valeur.
Spécifiez une chaîne de Le modèle {Oui,Non} pour
caractères qui servira de le champ marié de la table
Modèle
modèle aux valeurs employé.
acceptées dans ce champ
Tableau 11 : les contrôles de validité

 Le Module Base de données enregistre les contrôles de validité dans un fichier
séparé portant le nom de la table et l'extension .VAL.
2. Table de références :
La référence à une table est une fonction qui permet de:
 Rechercher dans une autre table les valeurs autorisées d'un champ
 Copier automatiquement les valeurs de la table de référence dans la table
que vous modifiez (remplissage automatique)
 Exiger que les valeurs entrées dans un champ existent dans le premier
champ d'une autre table L'avantage principal des tables de référence est
de garantir que les données soient recopiées correctement d'une table à
l'autre.
Règles pour les tables de références :

 Les données à copier de table de référence doivent être celles du premier champ.
 Le champ possédant la référence à une table doit être de même type et de même
taille que le premier champ de la table de référence.
 Pour obtenir les meilleures performances, la table de référence doit être indexée.
87
 Exemple :
La table de référence pour le champ CodeCl de la table Commande est la table
Clients(le champ CodeCl) signifie que:
 toute valeur entrée dans le champ CodeCl de la table Commandes doit
correspondre à une valeur existante dans le champ CodeCl de la table Clients.
Figure 57: table de référence
3. Intégrité référentielle :
L'intégrité référentielle implique qu'un champ ou un groupe de champs d'une table (la
table "enfant") fasse référence à la clé d'une autre table (la table "parent"). Le Module
Base de données n'accepte pour les champs spécifiés de la table enfant que les valeurs
existantes dans la clé de la table parent.
Exemple :
Supposons que vous avez établi une relation d'intégrité référentielle entre les tables
Clients et Commande sur leur champ CodeCl. Lorsque vous saisissez une valeur dans le
champ CodeCl de Commande, le Module Base de données examine le champ CodeCl
de Clients et :
 Accepte la valeur dans Commande si elle existe dans Clients
 Rejette la valeur si elle n'existe pas dans Clients
88
Figure 58:intégrités référentielles: exemple

4. Sécurité par mot de passe :
Vous pouvez vous assurer que la table que vous créez soit protégée contre l'accès
d'utilisateurs non autorisés. Cela est particulièrement important dans un
environnement multiutilisateur. Lorsque vous spécifiez un mot de passe, seuls les
utilisateurs connaissant ce mot de passe peuvent accéder à la table. Chaque fois
qu'un utilisateur essaie d'accéder à une table protégée par mot de passe, le Module
Base de données lui demande de le fournir.
Le Module Base de données possède deux types de mots de passe:
 Le mot de passe principal contrôle tous les accès à toute la table. Vous devez
spécifier un mot de passe principal avant de pouvoir créer des restrictions
d'accès supplémentaires.
 Les mots de passe secondaires permettent d'attribuer différents niveaux d'accès
aux différents types d'utilisateurs d'un groupe.
Figure 59: modification du mot de passe
89
VII.3.2. Restructurer, voir la structure :

Si vous voulez porter des modifications à une table, Pour vous devez ouvrir
d’abords la table (Fichier/Ouvrir/Table ou bien l’outil Ouverture d’une table )
puis cliquez sur l’icône Restructurer.
Ou bien utilisez la commande Restructurer du menu Table.
Figure 60 : restructuration d’une table

VII.3.3. Ouvrir, éditer les données :
La commande Editer les données du menu Table ou bien l’outil Editer les
données vous permettent de commencer à remplir la table à partir du module Bases
de données.
Figure 61: édition des données

90
VII.4. Les composants d’accès aux BDD :
VII.4.1. Le composant Table :

C’est un composant de la page BDE, il est de type « ensemble de données ». Il
encapsule toute la structure et les données d’une table de base de données.
Propriétés :
DataBaseName Spécifie le nom de la BDD ou de son Alias
Spécifie le nom de la table encapsulé par le composant
TableName
TABLE.
De type Boolean. Indique si la table est ouverte en lecture
Active
/écriture par d’autres composants.
Définis le nom de la source de données (DataSource) à
MasterSource utiliser comme table maitre dans une relation Maître-Détail
entre cette table et une autre
Spécifie un ou plusieurs champs d’une table maître à lier
MasterField
avec les champs correspondants de cette table
Tableau 12 : propriété du composant Table
VII.4.2. Le composant DataSource :

Accessible à partir de la page AccèsBD.
 DataSource sert d’interface entre un composant ensemble de données (Table,
Query,…etc) et les contrôles d’une fiche (DBGrid, DBEdit,….etc)
 Il sert aussi à lier deux ensembles de données dans une relation maître-détail.
Propriétés:
DataSet : Définit le nom (propriété Name) de l’ensemble de données qui utilise le
DataSource comme canal vers les contrôles orientés données ou autres
ensembles de données
VII.4.3. Le composant Query :

Le composant Query (requête), accessible par la page BDE, permet d'accéder à une ou
plusieurs tables d'une base de données en utilisant des instructions SQL *. 0F
Le composant Query permet d’ effectuer une sélection sur une base de données. Il est
identique au composant Table, mis à part la provenance des données.
Les composants requête sont pratiques, car ils peuvent accéder à plusieurs tables à la
fois (ce qu'on appelle en SQL une «jointure»).
Propriétés :
Active Exécute ou non la requête
DataBaseName Nom de la base de données interrogée
DataSource Origine des valeurs à fournir aux paramètres de la requête
Params Paramètres de la requête
SQL Libellé de la requête SQL
Tableau 13 : propriétés du composant Query
(* ) SQL : Structured Query Language, en français langage de requête structurée

91
VII.5. Les composants contrôles BD :
VII.5.1. Le composant DBGrid :

Le DBGrid (Grille BD) (page ContrôleBD), permet d’ affiche et de manipuler les
enregistrements d’ un ensemble de données (table ou requête) dans une grille tabulaire.
Une application Delphi peut utiliser DBGrid pour insérer, supprimer ou modifier les
données de la BDD ou simplement pour les afficher.
Propriétés :
DataSource : Indique le nom du DataSource Lié à l’ensemble des données d’où le

DBGrid tire ses données
Options : Ensemble de valeurs logiques (Boolean) qui contrôle le
comportement et l’aspect de DBGrid à l’exécution :
dgEditing: interdit ou autorise la modification, l’insertion et la
suppression des enregistrements
dgTitles: active ou désactive l’affichage des noms de champs en
haut de la grille
VII.5.2. L e composant DBNavigator :

Accessible à partir de la page ContrôleBD
 Fournit un ensemble d boutons permettant à l’utilisateur de naviguer parmi les
enregistrements de l’ensemble de données et de les manipuler.
Premier
Premier
Suivant
Insérer
Editer
Supprimer
Actualiser
Dernier
Précédent
Enregistrer
Figure 62: les bouton d'un DBNavigator

Propriétés :
DataSource : Indique le nom du DataSource Lié à l’ensemble des données

contrôlé par le DBNavigator
VisibleButtons : Ensemble de valeurs logiques qui détermine quels boutons
apparaissent dans le navigateur.
Les indicateurs des boutons sont: nbFirst, nbPrior, nbNext, nbLast,
nbInsert, nbDelete, nbEdit, nbPost, nbCancel, nbRefresh
92
VII.5.3. Le composant DBEdit :

Représente un contrôle de saisie mono-ligne pouvant afficher et modifier les valeurs
d’un champ.
Propriétés :
DataSource : le nom du DataSource Lié à l’ensemble des données

DataField : Le nom du champ correspondant
VII.5.4. Le composant DBImage :

Ce composant sert à afficher des images dans une base de données.
Propriétés : idem que DBEdit.
 Exemple d’application :
Dans cet exemple, on va créer une application qui permet de gérer une base de données
(gestion des étudiants), dans laquelle on va utiliser les composants d’accès et de
contrôle BD.
Cette application se compose de deux fenêtres (fiches) : la fiche principale et la fiche
Etudiant.
La fiche principale « main »
La fiche étudiant
93
 La commande « Nouveau » du menu principal permet d’afficher la fiche

« étudiant ».
 La commande « Quitter » permet de quitter l’application.
 Le bouton de la fiche « étudiant » permet de fermer cette dernière.
Etapes de réalisation :
1. Commencez d’abords par la création d’un nouveau dossier « E:\tp », puis passer
à la création de l’alias « getud ».
2. Créer la table « etudiant » :
3. Création de la fiche « main » :

a. Lancez Delphi.
b. Enregistrer la première unité « unit1 », puis le projet sous le nom
« Gest_etud ».
c. Renommer form1 par « main ».
d. Déposez un composant MainMenu, puis insérer les deux commandes
« Nouveau » et « Quitter » en double cliquant sur ce composant.
4. Création de la fiche « etudiant » :
ère
1 méthode : à l’aide de l’expert fiche :
a) Dans le menu de Delphi, faire Fichier / Nouveau/Autre. Déplacer entre les
onglets pour aller chercher l'onglet "Affaires".
b) Cliquer sur Expert fiche base de données.
94
c) Une boite de dialogue s'ouvre vous demandant "Quelle type de fiche voulez
vous que l'expert crée ?
d) Laissez les réponses par défaut (créer une fiche simple et créer une fiche avec
TTable). Cliquez sur suivant.
e)
f) Dans la case Lecteur ou nom d'alias, choisissez l'alias que nous avons créé
("getud"). Cliquez alors sur le nom de votre table (etudiant.db). Cliquez sur
suivant.
95
g) Vous devez alors indiquer quels sont les champs de la base que vous souhaitez
utiliser. Vous pouvez les sélectionner tous en cliquant sur le bouton ">>".
Cliquez sur suivant.
h) Choisissez alors une disposition pour les champs
Horizontalement ou
Verticalement (à choisir pour avoir des résultats similaires dans la suite de

l'exemple) ou
Dans une grille.
i) Faire "suite"
j) Choisir si vous voulez les libellés à gauche ou à droite (pour l'exemple :
prendre à gauche)
k) Faire "suite" puis terminer en laissant coché "générer une fiche maître" et pour
génération de fiche : "fiche seulement".
l) Et voila, Delphi vous a généré une fiche :
96
m) Maintenant, il faut activer la table : Active : True, et la renommer (Name :

etud).
n) Voila, votre fiche est fonctionnelle, vous pouvez la tester maintenant.
2eme méthode : utilisation directe des composants :

Les pages qui vont être utilisées dans cette partie sont:
 La page BDE: le BDE (Borland DatabaseEngine) représente le meilleur moyen
pour exploiter une BDD Paradoxou des tables Dbase.
 La page ContrôleBD: contient différents composants visuels (contrôles) de
manipulation des BDD
 La page AccèsBD
Etapes de réalisation :
1. Fichier/nouveau/fiche
2. Enregistrer la nouvelle fiche et modifier les propriétés : Name et Caption à
« etudiant ».
3. Déposer les composants suivants sur la fiche « etudiant » :
• Table à partir de l’onglet BD.
• DataSource à partir de l’onglet AccèsBD.
• A partir de l’onglet ContrôleBD : un DBNavigator, 5 DBEdit, un
DBGrid.
• 5 Label à partir de l’onglet Standard.
• A partir de l’onglet Supplément, 6 Bitbtn.
4. Les propriétés de chaque composant :
• Table1 :
 Databasename : getud
 Name : etud
 Tablename : etudiant.db
 Active : true
• Datasource1 :
 Dataset : etud
• DBNavigator1 :
 DataSource: DataSource1
• DBGrid :
 DataSource : DataSource1
• DBEdit :
 DataSource : DataSource1
 DBEdit1 : DataField :Code
 DBEdit2 : DataField :Nom
 DBEdit3 : DataField : Prenom
 DBEdit4 : DataField :Date_naissance
 DBEdit5 : DataField :Specialite
Et voila, vous avez le même résultat.
97
Vous pouvez remplacer le composant DBEdit5 par le composant

DBComboBox. Ce dernier a le même rôle que DBEdit, mais il possède
la propriété « Items » qui permet d’avoir une liste de choix.
Passons maintenant aux boutons :

• Affectez les valeurs « Fermer », « Insérer », « Annuler », « Enregistrer »,
« Modifier » et « Supprimer » aux propriétés Caption des boutons.
• Insérer maintenant la ligne du code correspondante à chaque bouton :
Fermer : close ;
Insérer : etud.Insert ;
Annuler : etud.Cancel ;
Enregistrer : etud.Post ;
Modifier : etud.Edit ;
Supprimer : etud.Delete ;
Vous avez maintenant le choix d’utiliser le DBNavigator ou bien les boutons.
5. Les liens entre les fiches :
a. Afficher la fiche « main ».
b. Activer le menu Fichier de Delphi /Utiliser l’unité/sélectionner ‘unit2’.
c. Cliquer sur le la commande ‘Nouveau’ de la fiche ‘main’ et écrire la
ligne du code suivante : etudiant.Show;
d. Cliquer sur la commande ‘Quitter ‘ puis écrire : application.Terminate;
6. Exécutez.
VII.6. L’impression et les états de sortie :

VII.6.1. QuickReport :
 QuickReport est un ensemble de composants qui permettent d'imprimer des
états issus de vos bases de données.
 C’est un générateur d'état livré avec les versions "Profesionnel" et "Entreprise"
de Delphi. Depuis la version 7 de Delphi, Borland a choisi de prendre
dorénavant le générateur d'états RaveReport. Toutefois, vous pouvez toujours
utiliser QuicReport. Pour cela, il suffit d'installer le paquet "dclqrt70.bpl" dans
le répertoire "Delphi\Bin".
Installation des composants Quickreport en Delphi7 :
98
99
Voici l'ensemble des composants QuickReport (il peut y avoir quelques changements dû
aux différentes versions) :
QRLabel
QRExpr
QRDBImage
QRSysData
QRDBText
QuickRep
Figure 63: la page QReport

VII.6.2. QRBand :
Un type de bande générique, qui peut jouer différents rôles en fonction de la propriété
BandType.
Pour créer un rapport (état d’impression), on combine essentiellement des bandes sur un
conteneur QuickRep, puis on définit leurs types à travers la propriété BandType.
Dans l’inspecteur d’objet :
Généralement, il n'est pas nécessaire de faire glisser un QRBand sur un

rapport. Utilisez plutôt la propriété Bands de QuickRep, qui crée des objets
TQRB et définit leur type de bande en une seule fois.
100
VII.6.3. QRLabel :
L'emploi du composant QRLabel ressemble à un label ordinaire, valable seulement pour
les états. Utilisez ce composant pour imprimer du texte statique sur un état en entrant du
texte dans la propriété Caption.
VII.6.4. QRDBText :
Utilisez le composant QRDBText pour imprimer tout champ texte d'une table, à
l'exception des champs mémo au format RichText. QRDBText peut imprimer des
champs alphanumériques, des champs à virgule flottante, des champs date et heure et
des champs mémo.
QRDBText peut s'étendre verticalement pour s'adapter au texte, si celui-ci excède la
taille originale. La propriété AutoStretch doit être définie à True pour permettre
l'étirement. Un composant peut s'étendre sur plusieurs pages.
Pour formater les sorties, utilisez la propriété Mask.
Propriétés :
DataSet : Choisir une table
DataField : Choisir un champ de la table
Mask : Utilisez la propriété Mask pour formater le résultat du composant
TQRDBText. Si aucun masque n'est spécifié, QuickReport utilise le
formatage par défaut pour le champ.
VII.6.5. QRExpr :
Utilisez QRExpr pour calculer une expression durant la génération d'un état.
Dans la propriété Expression, entrez l'expression à évaluer.
Figure 64: boite de dialogue Expert d'expression
101
 Exemple d’application :
Pour comprendre le fonctionnement de QuickReport avec Delphi, nous allons réaliser
un exemple utilisant la base de données qui a été créé dans l’exemple précédent.
(Gestion des étudiants).
1. Lancer le projet Gest_etud.
2. Ajouter une nouvelle fiche (name : liste)
3. Activer l’onglet QReport et déposer un composant QuickRep.
4. Déposer un composant Table dont les propriétés sont les suivantes :
• DatabaseName : getud
• Name : etud
• TableName : Etudiant
• Active : True
5. Mettre la propriété "DataSet" du composant QuickRep1"etud".
6. Modifier la propriété Bands du QuickRep1 :
7. Déposer un composant QRLabel dans la zone « Titre » et lui changer la valeur

caption à « LISTE DES ETUDIATS ».
8. Déposer 5 composants QRLabel dans la zone « en-tête de colonne » puis
modifier leurs propriétés « Caption » en (CODE, NOM, PRENOM, DATE DE
NAISSANCE, SPECIALITE).
9. Déposer 5 composants QRDBText dans la zone « Détail » et modifier leurs
propriétés «DataSet » à « etud » et « DataField » selon les noms des champs
comme si indiqué dans l’illustration ci-dessous :
10. Enregistrer
102
Passons maintenant à la création du lien entre le menu principal et l’état

d’impression :
11. Afficher la fiche « main » puis double cliquer sur le composant MainMenu1.
12. Faites un clic droit sur la ligne séparatrice puis cliquer sur « insérer ».
13. Ajouter maintenant la commande « Imprimer ».

14. Cliquer sur la commande « Utiliser l’unité » du menu Fichier de Delphi et
sélectionner « unit4 ».
15. Cliquer sur la commande « Imprimer » et ajouter la ligne du code suivante :
liste.QuickRep1.Preview;
16. Vous pouvez exécuter maintenant, et si vous voulez visualiser ou imprimer la
liste des étudiants, cliquer sur « Imprimer »,
17. Une fois la liste est affichée, cliquer sur imprimer.
Si vous voulez afficher un seul enregistrement, mettez uniquement la propriété

HasDétail du QuickRep1 à True, puis déposer les champs selon l’image ci-dessous :
103
VII.7. Exercice pratique :

Prenez l’exercice de synthèse du chapitre précédent (gestion employé). (VI.7. exercice
de synthèse)
Dans cet exercice, rappelez-vous que le menu principale, les fiches et liens entre ces
fiches sont créés déjà.
Maintenant, tu as pour mission de concevoir une base de données qui permet de manipuler
les renseignes des employés.
L’application donc se compose des fiches suivantes :
La fenêtre principale
104
La fiche « employe »
 La commande « NOUVEAU » permet d’afficher la fenêtre « employe »

 La commande « A PROPOS » permet
d’afficher le message suivant :
 La commande « QUITTER » permet de

quitter l’application.
VII.8. Résumé :
Ce chapitre est maintenant terminé. L'écriture m'en aura pris en temps incroyable, et
pourtant il ne contient pas toutes les notions que j'avais envisagé d'y placer au
départ.
Maintenant, vous êtes surement prêt à concevoir votre première base de données,
commençant par la création de l’alias, les tables et terminant par la réalisation des
états d’impression.
105
VII.9. Exercice de synthèse :

Durée : 1h30 mn
But : créer une base de données simple qui permet d’imprimer un état.
Matériels requis :
 SGBD (Delphi7)
Mise en situation :
Dans cet exercice, vous devez réaliser une application qui permet d’imprimer la fiche de
renseignements suivante et la liste des employés selon les modèles ci-dessous:
FICHE DE RENSEIGNEMENTS
Nom : …………………………..
Prénom : ………………………….
Date de naissance :………………………à ……………………………..
Fonction : …………………………………………
LISTE NOMINATIVE
Num Nom Prénom Date et lieu de naissance Fonction

1
2
3
4
5
NB : Vous pouvez prendre l’exercice précédent (gestion des employés) comme exercice
de base.
Marche à suivre :
 Etape 1 : lancer le projet
 Etape 2 : création des états
 Etape 3 : saisie des lignes du code
106
Chapitre VIII Distribuer une application de type Delphi
VIII. Distribuer une application de type Delphi :

Introduction :
Lorsque vous commencerez à faire des logiciels assez grands, vous aurez sûrement
envie de créer un programme d'installation (pour tous types de logiciels, qu'il soit
réalisé en Delphi, en C++ Builder, en Java…)
Dans ce chapitre, on va vous montrer comment créer un programme d'installation pour
vos applications.
VIII.1. L’assistant : InstallShield :

InstallShield Express est livré avec les versions pro et client serveur de Delphi et il est
téléchargeable à partir d’Internet. Il permet de réaliser des programmes d'installation au
look professionnel.
Il facilite également grandement l'installation de programmes complexes puisqu'il

permet de :
• copier n'importe quel fichier dans le répertoire approprié,
• installer si besoin le moteur de base de données Borland,
• ....
Ici, on a utilisé InstallShield 2016.
VIII.2. Création de l’installable de l’application :
Pour créer l’installable de votre application, suivez les étapes suivantes :

1. Lancez InstallShield 2016
107
Figure 65: l'écran d'accueil d'InstallShield 2016

2. Cliquer sur « Create a new project »
3. Dans la fenêtre qui s’affiche, activer l’onglet Windows Installer.
4. Cliquer sur « Basic Msi Project »
5. Dans la zone « Project Name », donner un nom à votre projet.
6. Dans la zone « Location », sélectionner la destination de votre projet
d’installation.
Figure 66: la fenêtre Windows Installer

108
7. Cliquer sur ok.

8. En bas de la fenêtre qui s’affiche « Project Assistant », cliquer sur
9. Cette fenêtre vous permet de spécifier les informations concernant votre projet
(nom de la société, nom de l’application la version et le site web)
10. Cliquer maintenant sur l’icône

11. Si votre application ne requiert pas un certain système d’exploitation ou un
programme pour fonctionner, vous pouvez garder cette fenêtre tel quelle est et
passer à l’étape suivante.
Figure 67: la fenêtre Installation Requirements
12. Cliquer sur l’icône
109
13. Dans cette étape, vous devez sélectionner les fichiers nécessaires à votre
application en cliquant sur le bouton « Add Files »
Figure 68: Ajout des fichiers
14. Dans votre cas (application BDD), vous sélectionner le fichier exécutable (.exe)
et les tables.
15. Voila, c’est très simple, il ne vous reste que de cliquer sur l’icône
pour terminer l’opération.
16. Dans cette étape, cocher la case « Single MSI Package » (ou bien la case
CD_Rom si vous voulez lancer l’installation à partir d’un Cd_Rom) puis cliquer
sur le bouton « Build Installations »
110
17. Si vous voulez faire un test, vous pouvez accéder au dossier qui con contient
l’application et double cliquer sur le fichier « setup ».
Par exemple :
VIII.3. Exercice pratique :
Créez un installable pour vos documents enregistrés sur votre disque dur.
VIII.4. Résumé :
Grâce à l’utilitaire InstallShield, vous avez maintenant à votre disposition un outil

efficace pour installer vos applications et vos logiciels sans passer par le
copier/coller qui prend énormément de temps et de place.
VIII.5. Exercice de synthèse :

Durée : 30 mn
But : créer l’installable d’une application BDD.
Matériels requis :
 SGBD (Delphi7)
Mise en situation :
Dans cet exercice, Tu as pour mission de créer un installable pour votre application créé
dans les exercices précédents (GESTION DES EMPLOYES) puis réinstallez la dans un
autres lecteur.
Marche à suivre :
Etape 1 : lancer InstallShield 2016

Etape 2 : créer le projet d’installation
Etape 3 : tester l’installation
111
Résumé Général
Résumé général :
Tout au long des huit chapitres de ce manuel, vous avez pu avoir une idée
sur la manière dont Delphi travaille, et ceci en utilisant :
 Les différents éléments de l’EDI.
 Les barres d’outils
 L’inspecteur d’objet
 Les pages (ou onglet) qui offre un nombre très importants de
composant qui permettent de manipuler les applications.
 Le moteur Base de Données et l’Administrateur BDE, et le code
source (en langage Pascal).
Tous ces éléments, qui ont fait l’objet de ce manuel vont vous aider à se
familiariser avec le monde de développement des applications.
Ce manuel vous a mis aussi sur le chemin de la création des installables des
applications grâce à l’utilitaire InstallShield.
112
Exercice de synthèse général
Exercice de synthèse général :
Durée : 4 Heures
But : création et manipulation d’une base de données
Matériels requis :
 SGBD (Delphi7)
 MLD
Mise en situation :
Vous êtes un Technicien Supérieur en Informatique spécialisé en bases de données, un

professeur vous demande de lui créer une application qui lui permet d’établir le pv de
notes ci-dessous, et qui permet d’effectuer les opérations de modification et de mise à
jour de données.
Date et lieu Maths Stat. Inf Ang

Total Moy
Num Nom et prénom de Coef Coef Coef Coef Gl Gle
naissance 4 3 3 2
2031 MM Samir 20/03/2000 12.50 14 12 13
2032 DD Dounia 31/01/2000 15.75 16 13 15
2033 SS Samia 25/04/2001 10 12 10.25 13
2034 BB Soheib 15/06/2000 8.75 13 14 10
2035 NN Amine 10/10/2001 15 15 14.50 13
Marche à suivre :
 Etape 1 : création de la base de données (alias, tables)

 Etape 2 : exploitation des tables (création des menus et des fiches
 Etape 3 : création de l’état d’impression
 Etape 4 : effectuer les calculs
 Etapes5 : création des liens entre les fiches.
113
Grille d’évaluation formative
Grille d'évaluation formative

Module : Delphi Monoposte « Implanter les Bases de Données en Monoposte ».
Grille d'évaluation formative
Evaluation
Stagiaire Formateur
Eléments d'observation
Résultats Résultats
Oui Non Non Oui
1. Explication des notions de base :
1.1. Expliquer les notions relatives à Delphi
1.1.1. Programme
1.1.2. Application/Projet
1.1.3. Interface
2. Description de l’EDI :
2.1. La barre des menus
2.2. La barre d’outils
2.3. La palette des composants
2.4. La fiche et l’unité
2.5. L’inspecteur d’objets
3. Création des applications simples
3.1. Créer et enregistrer un projet
3.2. Ajouter de nouvelles fiches
3.3. Compiler et exécuter le projet
4. Utiliser les propriétés et les événements d’un objet
4.1. Utiliser l’onglet « Propriétés » de l’inspecteur d’objet
4.2. Utiliser l’onglet « Evénements » de l’inspecteur d’objet
5. Manipulation des composants :
5.1. Accéder à l’onglet correspondant
5.2. Déposer le composant sur la fiche
5.3. Modifier valeurs des propriétés
5.4. Afficher les messages
6. Créer une application multi fiche
6.1. Créer un nouveau projet
6.2. Créer le menu principal
6.3. Créer et lier les fiches
7. Concevoir et utiliser une base de données
7.1. Créer correctement un alias
7.2. Créer les tables
7.3. Connecter la table avec les composants d’accès et de contrôle
BD
7.4. Créer les états de sortie
8. Distribuer une application conçue avec Delphi
8.1. Créer l’installable de l’application avec InstallShield
8.2. Tester le projet d’installation de l’application.
114
bibliographie
Bibliographie :
BELAID, Mohamed Chrif. Delphi, de l’initiation à la maitrise, Alger, Editions

01
Pages bleues internationales, 2005.
S.Graine , Delphi 7, Concepts de bases de données, Tizi-Ouzou, Editions
02
l’Abeille, 2006.
INFEP, Guide méthodologique d’élaboration du manuel du stagiaire (MTPS),
03
Alger, 13 juin 2013
04 Frédéric Beaulieu, Guide Pascal et Delphi, 2008, pdf
05 KHADRAOUI Fairouz, Les Bases de données avec DELPHI, 2013, pdf
06 Université Lumière, Lyon, Programmation sous Delphi, 2000, pdf
07 BOUNCEUR Ahcène, cours de Delphi, pdf
08 Guide du développeur Delphi 7, pdf
Web graphie :
http://www.depannetonpc.net/lexique/lire_56_programmation-orientee-objet.html 14/05/2017
[1]
15 :30
[2] http://delphipage.free.fr/boutons.html 02/07/2017 20h00
[3] http://fbeaulieu.developpez.com/guide/ 16/05/2017 10h00
https://phidels.com/php/index.php3?page=../php/mescom po/bitbtnannule.htm&id=222
[4]
20/07/2017 15h30
[5] https://info.sio2.be/delphi/1/12.php 20/07/2017 17h00
[6] http://users.skynet.be/computelec/contstandards.htm 03/06/2017 15h30
[7] http://pascalien.pagesperso-orange.fr/Delphi.htm 15/06/2017 14h20
[8] http://delphi.dev-dz.com/cours/bde.php 12/08/2017 9h00
https://fr.scribd.com/doc/17473727/Introduction-Aux-Bases-de-Donnees-Sous-Delphi
[9]
04/08/2017 14h30
[10] https://www.gladir.com/CODER/DELPHI/referencedate.htm 20/07/2017 18h00
http://docs.embarcadero.com/products/rad_studio/delphiAndcpp2009/HelpUpdate2/EN/html/d
[11]
elphivclwin32/StdCtrls_TListBox_MultiSelect.html 20/08/2017 22h30
[12] https://www.jmdoudoux.fr/delphi/langage.html 14/05/2017 14:55
https://fr.scribd.com/doc/17473695/Introduction-a-la-Programmation-Orientee-Objet-
[13]
PASCAL 10/08/2017 15h00
https://openclassrooms.com/courses/programmez-en-oriente-objet-avec-c/introduction-a-la-
[14]
programmation-orientee-objet-1 14/05/2017 14:40
115
bibliographie
116

Delphi 7

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Delphi 7

Transféré par

Droits d'auteur :

Formats disponibles

Chapitre I Description de l’environnement Delphi

I. Description de l’environnement Delphi :

Nous ne décrirons pas ici la procédure d'installation de DELPHI à partir

I.1. Définition de Delphi :

 C’est un logiciel de conception d’applications fonctionnant sous Windows.

Figure 1 : la fenêtre Delphi 7

I.3.1. La barre des menus :

Figure 2 : la fenêtre principale Palette de composants

 Le menu Fichier permet d'ouvrir un nouveau fichier, un nouveau projet,

Il ne s'agit pas ici de connaître chacun des éléments de menus de Delphi,

I.3.2. La barre d’outils :

Nouveau ouvrir enregistrer tout ajouter un fichier

Enregistrer ouvrir un projet Retirer un fichier

Figure 3 : barre d’outils standard

Voir une unité Basculer fiche/unité

Voir une fiche nouvelle fiche

Figure 4 : barre d’outils Voir

I.3.3. La palette des composants :

Figure 5: structure interne d'un composant

Les plus couramment utilisés sont ceux de l’onglet "Standard".

Figure 6 : palette des composants

Button Bouton d'action: c'est le composant le plus utilisé

Tableau 01: Les composants de la page Standard

 Comment utiliser les composants de la palette ?

Figure 7 : exemple de fiche

Figure 8 : exemple d’unité

Attention cependant à ne pas tomber dans l'excès : certaines unités

Il n'est pas conseillé de modifier ce qui a été écris par l’éditeur de

I.3.5. L’inspecteur d’objet :

 L'inspecteur d'objets vous permet de modifier les propriétés et d'accéder aux

Trois utilisations sont possibles:

Ici, on peut voir qu'il s'agit des caractéristiques générales

Figure 9 : l’inspecteur d’objets

I.4. Exercice théorique :

- Quelle sont les propriétés utilisées sur la fiche ?

Voilà, vous en savez maintenant assez sur Delphi pour le moment :

I.7. Exercice de synthèse :

Spécialité : Informatique / Option : Bases de Données

Dans cet exercice, vous devez créer l’interface suivante :

 Etape 1 : déposer les composants sur la fiche

II. Créer une application simple :

 Un projet est l’état non compilé d’une application

1ere étape : création des fiches :

 Exemple : un bouton placé sur ne fiche :

3eme étape : associer des évènements aux composants :

Figure 10 : éditeur de code

4eme étape : enregistrer le projet

Il est utile de consacrer complètement un répertoire (dossier) à

Figure 11 : enregistrement de l’unité

Figure 12 : enregistrement du projet

 Chaque fiche est stockée dans un fichier avec l’extension « .DFM »

Nom de base + associés

Fichiers contenu des fichiers

Figure 13 : les fichiers d’un projet Delphi

Après quelques instants de travail, le logiciel nous redonne la main. La compilation a eu

Figure 14 : compilation d’un projet

Unité 1 Fiche1 Fichier 1

Unité 2 Fiche2 Fichier 2 Fenêtre Fenêtre

Projet Compilation Application

Figure 15 : compilation d’un projet

II.5.Ajouter des nouvelles fiches :

Figure 16 : insérer une nouvelle fiche

Figure 17 : gestionnaire de projet