Delphi5 Simple

12e Technique Générale
Année académique : 2001/2002
Titulaire : Serge Linckels

: [email protected]
© 1999-2001, LTE, Serge Linckels 12GE Informatique
Chapitre 1 : L'approche objet
1.1. Introduction
Montres
Toute chose, vivante ou non, peut être
appelé objet.
Chaque individu décrit un même objet

différemment parce que chaque observateur
a sa propre personnalité. Ainsi, chacun
attribue d'autres importances aux critères
d'un objet, c'est l'abstraction.
On dit que chaque personne a une

perception différente de la même chose.
Abstraction : ignorer les propriétés marginales et concentrer sur les aspects essentiels
1.2. Exemple : Analyse de l'objet _________________________
1.2.1. Description
Propriétés : ensemble des caractéristiques qui décrivent un objet
En informatique, l'abstraction nous permet de ne considérer que les caractéristiques les plus
importantes des objets que nous manipulons.
1.2.2. Actions possibles
Méthodes : ensemble des fonctions d'un objet
Version du : 30/12/01 Page 2

1.2.3. Représentation graphique
nom de l'objet
propriétés
méthodes
1.2.4. Événements
Un objet existe dans un certain environnement. Il est impossible de prévoir ce qui va arriver à l'objet.
Donc, l'objet doit pouvoir réagir à des événements importants.
Événement : fait qui se produit à un certain moment donné et qui peu déclencher une
méthode
Exemples : Événement Méthode invoquée

Le chef arrive au bureau Travailler
La nourriture est mise sur table Manger
1.3. Cycle de développement
Par cycle de développement, on entend les différentes étapes pour réaliser une application selon
l'approche objet.
1.3.1. Analyse orientée objet
• Comprendre l'énoncé ;
• Trouver une solution modèle ;
• Identifier les objets nécessaires ;
• Identifier les propriétés et méthodes de chaque objet.
sur papier
1.3.2. Conception orientée objet
• Création des structogrammes pour les méthodes complexes ;

• Vérification de n'avoir pas oublié des objets ;
• Élimination des objets doubles ou superflus.
1.3.3. Programmation orientée objet
• Création de l'interface utilisateur ; sur ordinateur

• Rédaction du code des méthodes ;
• Tests ;

Chapitre 2 : L'environnement Delphi
2.1. Présentation
• Delphi est un produit de l'entreprise Inprise (avant : Borland).

• Delphi permet de créer facilement des interfaces utilisateurs (programmation visuelle).
• Delphi génère automatiquement une partie du code (programmation d'application rapide).
Le noyau d'une application Delphi est une fiche, sur laquelle le programmeur pose des objets visuels.
Les propriétés peuvent être modifiés lors de la création d'une fiche, ou en cours d'exécution. Une
méthode peut être affectée à chaque événement prévu. Le corps des méthodes sont rédigés dans le
langage Pascal Objet.
Remarque : Une application Delphi peut être composée de plusieurs fiches. Les fiches sont alors
regroupées dans un projet. Pour nous, un projet = une fiche (projet et fiche ont le
même nom).
2.2. Vu sur les composants de base de Delphi
Un composant est un objet particulier qui peut être réutilisé dans différents contextes. Ci-dessous une
liste des principaux composants graphiques.
ListBox ComboBox Panel
EditBox Button CheckBox RadioButton
2.2.1. Le composant "Panel"
Description : Il s'agit d'une simple zone qui peut contenir un

texte.
Propriétés : Alignement alignement du texte (centré, gauche, droite)

Caption contenu (texte)
Color couleur de fond
Font police de caractère du texte
2.2.2. Le composant "Button"
Description : Il s'agit d'un bouton, contenant un texte et idéal

pour réagir sur l'événement "onClick".
Propriétés : Alignement alignement du texte (centré, gauche, droite)

Caption contenu (texte)

2.2.3. Le composant "EditBox"
Description : Il s'agit d'une zone où l'utilisateur peut entrer un

texte.
Propriétés : CharCase minuscules, majuscules, normal

MaxLength longueur maximale du texte à entrer
PasswordChar possibilité de cacher le retour des caractères par un symbol
Text contenu (texte)
2.2.4. Le composant "ListBox"
Description : Il s'agit d'un tableau qui peut contenir plusieurs

lignes de textes. Un "scroll-bar" s'affiche
automatiquement si le nombre de lignes dépasse
la zone visible.
Propriétés : Color couleur de fond

Items liste (tableau) des lignes
Sorted trie automatique de la liste
2.2.5. Le composant "ComboBox"
Description : Il s'agit d'une boîte à options. La zone d'édition

montre l'élément sélectionné dans la liste
déroulante sous-jacente.
Propriétés : Color couleur de fond

Items liste (tableau) des lignes
Sorted trie automatique de la liste
Text contenu de la zone d'édition
2.2.6. Autres composants
2.3. Conventions de dénomination
• Pour les propriétés on utilise le nom proposé par Delphi.

Exemple : Name, Visible, Caption, Font, etc.
• Pour les méthodes on utilise comme nom : nom_objet + nom_méthode

Exemple : btnCalculer.Click, btnFermer.Exit, etc.
btnCalculer est le nom de l'objet

Click est le nom de la méthode
• Le nom d'un objet se compose comme suit :

− Il commence par un préfixe qui indique de quel composant il s'agit (voir paragraphe suivant).
− Il suit le nom de l'objet proprement dit (un ou plusieurs mots, sans espaces).
− Chaque première lettre d'un mot est écrit en majuscule.
Exemple : lblResultat, btnCalculerDelta, etc.

Liste des préfixes :
Barre d'outils Préfixe Composant Icône

Barre d'outils Préfixe Composant Icône
Standard mm TmainMenu
Additional bbtn TBitBtn
pm TPopupMenu
sb TSpeedButton
mmi TmainMenuItem
me TMaskEdit
pmi TPopupMenuItem
sg TStringGrid
lbl TLabel
dg TDrawGrid
edt TEdit
img TImage
mem TMemo
shp TShape
btn TButton
bvl TBevel
ckb TCheckBox
sbx TScrollBox
rb TRadioButton
clb TCheckListBox
lb TListBox
spl TSplitter
cb TComboBox
stx TStaticText
scb TScrollBar
Samples spe TspinEdit
gb TGroupBox
pb TPaintBox
rg TRadioGroup
tbr TTrackBar
pnl TPanel
tm TTimer
Win32 prb TProgressBar
2.4. L'inspecteur d'objets
Soit le programme suivant :
Un objet Panel

© 1999-2001, S. Linckels, LTE 12GE Informatique
2.4.1. La manipulation des propriétés
L'inspecteur des objets (Object Inspecteur) affiche toutes les

propriétés de l'objet sélectionné.
• Les propriétés de l'objet sélectionné peuvent être modifiées

dans l'inspecteur d'objet, par exemple les dimensions de
l'objet (Heigth, Width). Ces changements sont
immédiatement appliqués à l'objet sur la forme.
• Si l'objet sélectionné est changé sur la forme, par exemple on

l'agrandit, alors la ou les propriétés correspondantes sont
immédiatement modifiées et visibles dans l'inspecteur d'objet.
La couleur de l'objet "Panel1"

est jaune "clYellow"
La police de caractère
est "Arial"
2.4.2. La manipulation des méthodes
Si un événement surgi à l'objet, par exemple que l'utilisateur

clique dessus (onClick), alors l'objet consulte sa liste des
événements et contrôle s'il y a une méthode qui est définie pour
cet événement.
Une méthode est disponible pour

l'événement "onClick"
ATTENTION : Faire la différence entre événement et méthode
Toute méthode est à réaliser par le programmeur dans le langage

Pascal Objet.
Version du : 30/12/01 20:47 Page 7

2.5. Exercices
• Tous les exercices sont à sauvegarder dans le répertoire personnel sous le nom
exact (par exemple : C1E1).
• Tous les objets, méthodes et formulaires portent la désignation appropriée.
• Chaque exercice est sauvegardé dans un répertoire à part (le nom du répertoire est le
même que celui de l'exercice) Une application Delphi a besoin de 6 fichiers
• Utiliser le menu : "save all"
• Réaliser pour chaque exercice la description des objets et la description des
méthodes.
2.5.1. Exercice C2E1
a) Créer une forme contenant un objet "Panel".

b) Le panel porte le nom : "pnlAffiche".
c) Le panel a la couleur bleue.
d) Le panel contient le texte "Hello world".
e) Si l'utilisateur click (avec la souris) sur le panel, sa couleur devient rouge. Si le bouton de la souris
est relâché, la couleur du panel devient à nouveau bleue.
a) Créer une forme contenant deux objets "Button", un

contant le texte "bleu", l'autre contant le texte "rouge".
b) Créer un objet "Panel" en couleur bleue, contenant le
texte "Hello world".
c) Si l'utilisateur click sur le bouton "bleu", la couleur du
panel change en bleu. Si l'utilisateur click sur le bouton
"rouge", la couleur du panel change en rouge.
Créer un programme qui permet à l'utilisateur d'entrer son nom. En appuyant sur un bouton pour
soumettre cette entrée, le programme affiche dans une petite zone le message "Bonjour <nom>".
Comment peut-on étendre ce programme ?
Travail à faire :
a) Ajouter un bouton à la fiche qui porte le nom BtON et le titre "ON". Le bouton BtON se désactive
soi même lors d'un clic (utiliser la propriété "enabled").
b) Ajouter un deuxième bouton BtOFF qui porte le titre "OFF" qui se désactive aussi lors d'un clic.
c) Modifiez les méthodes des deux boutons de façon à ce qu'il y ait toujours un bouton activé et un
bouton désactivé.
d) Remplacez les titres des deux boutons respectivement par "O&N" et "O&FF". Que constatez-
vous?
Version du : 30/12/01 20:47 Page 8

2.6. Conversions de types
En Delphi, il existe des fonctions prédéfinies permettant de convertir des chaînes de caractères dans
des nombres et vice versa :
inttostr( ) (Integer to string) conversion d'un nombre entier dans une chaîne de
caractères
floattostr( ) (Floating point number to string) conversion d'un nombre réel dans une chaîne
de caractères
strtoint( ) (String to integer) conversion d'une chaîne de caractères dans un entier.
Uniquement utilisable, si la chaîne de caractères contient la représentation
exacte d'un nombre entier.
strtofloat( ) (String to floating point number) conversion d'une chaîne de caractères dans
un nombre réel. Uniquement utilisable, si la chaîne de caractères contient la
représentation exacte d'un nombre réel.
Exemples :
Button1.Caption := inttostr(1000);
Edit1.Text := floattostr(sqrt(1000));
Label1.Caption := floattostr(0.5 * strtofloat(Edit1.Text));
2.7. Exercices
Développer un programme qui permet à l'utilisateur d'entrer deux valeurs et qui affiche la somme de
ces valeurs.
Faire le programme qui affiche la valeur absolue d'un nombre entier entrée au clavier.
Rappel mathématique :
 x si x ≥ 0
forme générale : x = (avec x une valeur lue au clavier)
− x si x < 0
Exemples :
42 = 42
−3 = 3
Réaliser un programme qui permet de résoudre une équation du deuxième degré à une inconnue.
Nous supposons que : a, b et c soient des nombres entiers et que a ≠ 0.
Version du : 30/12/01 20:47 Page 9

forme générale : ax 2 + bx + c = 0 (avec a, b et c des nombres lus au clavier)
∆ = b 2 − 4ac
si ∆ < 0, alors pas de solution
−b
si ∆ = 0, alors une solution: x=
2a
−b− ∆ −b+ ∆
si ∆ > 0, alors deux solutions : x1 = et x 2 =
2a 2a
Développer un programme qui calcule la somme de tous les nombres entiers entre deux limites
entrées par l'utilisateur.
• Dans un premier temps, nous supposons que la première limite soit plus petite que la deuxième.
• Dans un deuxième temps, l'exercice est à compléter par un mécanisme de "contrôle de saisie",
c'est-à-dire que le programme échangerait automatiquement les limites entrées, si la première
était plus grande que la deuxième.
Réaliser un programme qui permet à l'utilisateur

d'entrer deux valeurs entières X et N. Le programme
N
affiche ensuit le résultat de la puissance X .
Écrire un programme qui permet de simplifier le plus possible une fraction.
L'utilisateur entre le numérateur et le dénominateur. La fraction simplifiée (pas les résultats

intermédiaires) est à afficher.
Exemple 1 :
fraction initiale : 8/24
résultat : 1/3
Exemple 2 :
fraction initiale : 24/8
résultat : 3
Utiliser des variables intermédiaires au lieu de convertir plusieurs fois une chaîne de
caractères, en principe si cette information est utilisée plus qu'une fois.
Version du : 30/12/01 20:47 Page 10

Reáliser un programme qui permet d'additionner deux fractions (numérateur et dénominateur sont des
entiers). La fraction résultat est automatiquement simplifié.
La méthode à appeler pour terminer une application s'appelle : Application.Terminate.
Remarque : Si le résultat est irréductible, la simplification n'est pas affichée.
Version du : 30/12/01 20:47 Page 11

Chapitre 3 : Les sous-programmes
3.1. Introduction
Réaliser un programme qui permet de

calculer la factorielle de quatre nombres.
Commentaire :
Les quatre boutons Factorielle
effectuent plus ou moins le même
traitement (calcul de la factorielle d'un
nombre).
Remarque :
Plus un programme est long, plus il est complexe à lire et plus il est difficile à trouver d'éventuelles
erreurs.
Solution :
Idée Effet Concept
a) "Factoriser" une partie commune Le programme devient plus court
MODULARITÉ
des quatre méthodes est plus lisible
b) "Réutiliser" pour les quatre boutons Le calcul de la factorielle est
Factorielle le même traitement généralisé est indépendant de RÉUTILISATION
(calcul de la factorielle) l'interface utilisateur
3.2. Les notions de bases
3.2.1. Modularité
Tout système peut être organisé en un ensemble de sous-systèmes moins complexes, afin de le
rendre plus simple à comprendre. L'organisation d'un programme informatique en sous-programmes
est appelée : modularité.
3.2.2. Réutilisation
Un traitement qui est souvent utilisé (par exemple : une fonction mathématique), peut être généralisé.
Au lieu de copier et d'adapter le code pour chaque traitement, il peut être factorisé dans un seul sous-
programme. On parle de : réutilisation.
3.3. Comparaison : Sous-programme et méthode
3.3.1. Différences
Un sous-programme est un traitement indépendant, qui est ni attaché à un objet, ni à un

événement, il est même indépendant vis-à-vis de la forme (Form). Il peut être appelé à partir de
toute méthode.
Une méthode est un traitement qui appartient à un (ou plusieurs) objets de la forme. Elle est évoquée
suite à un certain événement (par exemple : appuyer sur un bouton, l'événement onClick).
3.3.2. Égalités
Dans un sous-programme et dans une méthode :

• peuvent être déclarés des variables ;
• peuvent se trouver toutes instructions possibles.
Version du : 30/12/01 20:47 Page 12

3.3.3. La notation
Le symbolisme utilisé pour représenter graphiquement un sous-programme est le même que pour une
méthode.
Chaque sous-programme porte un nom écrit en majuscule. Dans le nom du sous-programme ne

figure pas le nom d'un objet, puisqu'un sous-programme n'est pas lié un objet.
JUSTE : EXEMPLE FAUX : btnButton1.EXEMPLE
nom d'un objet
3.4. Les fonctions (Delphi : function)
3.4.1. Définition
appel
Une fonction est un sous-

sous-programme programme (avec ou sans
(fonction) paramètre), qui réalise un
certain traitement et qui retourne
une valeur.
résultat
3.4.2. Exemple (voir introduction)
Réaliser un programme qui permet de

calculer la factorielle de quatre nombres.
Description des objets :

Nous nous limitons à la description des
objets importants (Edit, Button et
Label pour les résultats).
edtA btnFacA lblA

Text ! "" Caption ! "Factorielle" Caption ! ""
btnFacAClick
edtB btnFacB lblB

btnFacBClick
edtC btnFacC lblC

btnFacCClick
edtD btnFacD lblD

btnFacDClick
Version du : 30/12/01 20:47 Page 13

Description des méthodes :
btnFacAClick Appel de la fonction FAC

avec un paramètre et retour
X ! strtoint(edtA.Text) du résultat.
Y ! FAC(X)
lblA.Caption ! inttostr(Y)
btnFacBClick
X ! strtoint(edtB.Text) La fonction retourne un

résultat du type longint
Y ! FAC(X)
lblB.Caption ! inttostr(Y)
FAC(N):longint
btnFacCClick
F ! 1
X ! strtoint(edtC.Text) I ! 2
Y ! FAC(X)
tant que I <= N
lblC.Caption ! inttostr(Y)
F ! F * I
I ! I + 1
btnFacDClick
FAC ! F
X ! strtoint(edtD.Text)
Y ! FAC(X)
lblD.Caption ! inttostr(Y)
Remarques :
• btnAClick est une méthode de l'objet btnA.

btnBClick est une méthode de l'objet btnB.
…
FAC est une fonction.
• N est le paramètre de la fonction FAC.
• F, I et N sont des variables de la fonction FAC. Elles sont inaccessibles en dehors de cette
fonction. On les appelle aussi : "variables locales à la fonction FAC".
X et Y sont des variables des différentes méthodes. Elles sont inaccessibles en dehors de leur
méthode.
• Au sein des méthodes :

La ligne Y ! FAC(X) appelle la fonction FAC avec la valeur de la variable X. A ce moment, N
prend la valeur de X. On peut dire aussi que N est une copie de X.
Après l'exécution de la fonction, elle retourne un résultat : la factorielle de X. Ce résultat est
affecté à la variable Y.
• Au sein de la fonction :
Le contenu de la fonction FAC est général, c'est-à-dire qu'il représente le calcul général de la
factorielle. Ce traitement est donc indépendant du reste du programme.
La dernière ligne de la fonction est l'affectation du résultat (ici : FAC ! F).
FAC(N) représente donc un nombre concret, celui de la factorielle de N.
Version du : 30/12/01 20:47 Page 14

Traduction en Delphi :
function FAC(N:integer):longint;
var I,F:integer;
begin
F:=1; La fonction doit être rédigée
I:=2; avant le code des méthodes qui
while I<=N do utilisent le sous-programme.
begin
F:=F*I;
I:=I+1;
end;
FAC:=F;
end;
procedure TForm1.btnFacAClick(Sender: TObject);

var X,Y:integer;
begin
X:=strtoint(edtA.Text);
Y:= FAC(X);
lblA.Caption:=inttostr(Y);
end;
procedure TForm1.btnFacBClick(Sender: TObject);

var X,Y:integer;
begin
X:=strtoint(edtB.Text);
Y:= FAC(X);
lblB.Caption:=inttostr(Y);
end;
procedure TForm1.btnFacCClick(Sender: TObject);

var X,Y:integer;
begin
X:=strtoint(edtC.Text);
Y:= FAC(X);
lblC.Caption:=inttostr(Y);
end;
procedure TForm1.btnFacDClick(Sender: TObject);

var X,Y:integer;
begin
X:=strtoint(edtD.Text);
Y:= FAC(X);
lblD.Caption:=inttostr(Y);
end;
3.5. Les procédures (Delphi : procedure)

appel
3.5.1. Définition
Une procédure est un sous-programme (avec ou

sans paramètre) qui réalise un certain traitement. sous-programme
Elle ne retourne pas un résultat. (procédure)
3.5.2. Différence de notation
La notation d'une procédure est identique à celle d'une fonction, sauf le détail de l'affectation du
résultat. Cette ligne n'existe pas dans une procédure.
Version du : 30/12/01 20:47 Page 15

3.5.3. Exemple
Réaliser un programme qui permet de changer

la couleur de cinq Panel en un coup en jaune
ou en vert.
Solution :
Pour réduire le volume de code et pour diminuer
la complexité du programme, il est conseillé
d'utiliser un sous-programme,
Ce sous-programme recevra comme paramètre
la couleur désirée. Le travail fastidieux
(changement de la couleur de chacun des
Panel) sera effectué au niveau du sous-
programme.
Remarque :
L'utilisation d'une fonction n'est pas appropriée,
puisque le sous-programme ne retourne pas de
résultat.
pnl1 pnl2 pnl3 pnl4

Caption ! "Panel1" Caption ! "Panel1" Caption ! "Panel1" Caption ! "Panel1"
Color ! clYellow Color ! clYellow Color ! clYellow Color ! clYellow
pnl5 btnJaune btnVert

Caption ! "Panel1" Caption ! "Tous jaune" Caption ! "Tous jaune"
Color ! clYellow
btnJauneClick btnVertClick
Appel de la procédure
ChgCouleur avec un
btnJauneClick
paramètre
CHGCOULEUR(clYellow)
CHGCOULEUR(C)
btnVertClick
pnl1.Color ! C
CHGCOULEUR(clGreen) pnl2.Color ! C
pnl3.Color ! C
pnl4.Color ! C
pnl5.Color ! C
Traduction en Delphi :
procedure procedure CHGCOULEUR(C:integer);

TForm1.btnJauneClick(Sender:TObject); begin
begin Form1.pnl1.Color:=C;
CHGCOULEUR(clYellow); Form1.pnl2.Color:=C;
end; Form1.pnl3.Color:=C;
Form1.pnl4.Color:=C;
procedure Form1.pnl5.Color:=C;
TForm1.btnVertClick(Sender:TObject); end;
begin
CHGCOULEUR(clGreen);
end;
Version du : 30/12/01 20:47 Page 16

3.6. Exercices

n
Développer une fonction PUISSANCE qui permet de calculer x pour n étant un entier supérieur ou
égal à 0.
Extension possible : n peut être un nombre négatif.
Écrire une fonction ROUND(X,N) qui permet d'arrondir un nombre réel X à N positions décimales.
L'instruction TRUNC peut être utilisée.
• Réaliser une fonction DEG2RAD qui permet de

convertir, un angle exprimé en degrés, en radians.
• Réaliser une fonction RAD2DEG qui permet de
convertir, un angle exprimé en radians, en degrés.
Remarque :
Utiliser la fonction ROUND de l'exercice précédent pour
présenter le résultat sous forme propre.
sin x
Développer une fonction TANGENTE, sachant que : tan x =
cos x
Utiliser la fonction ROUND de l'exercice C3E2 pour présenter le
résultat sous forme propre.
Attention : prévoir le cas où le dénominateur est zéro.
Remarque : Delphi exprime tous les angles par défaut en radians

(système américain).
Réaliser une fonction MIN et une fonction MAX qui retourne

respectivement le plus petit et le plus grand de deux nombres.
Extension possible :
• Réaliser une fonction MIN et une fonction MAX qui retourne
respectivement le plus petit et le plus grand de trois
nombres.
• Écrire un programme permettant de déterminer
le minimum et le maximum de quatre
nombres, en utilisant les fonctions MIN et
MAX.
Version du : 30/12/01 20:47 Page 17

Développer un sous-programme PYTHAGORE qui permet de

calculer la longueur d'un côté d'un triangle rectangle, quand
deux des trois côtés sont connus, en utilisant le théorème de
Pythagore. La longueur du côté à calculer est initialement 0.
Le sous-programme doit faire le décodage pour déterminer
la longueur à calculer.
Nous supposons qu'il a toujours exactement un côté

inconnu.
Dans le cas où l'utilisateur entre trois valeurs numériques
différentes de 0, il faut vérifier si le théorème de Pythagore
est vérifié pour ces valeurs (utiliser un autre sous-
programme : VERIF_PYTHAGORE). On affiche dans ce un
message adéquat.
Écrire une fonction permettant d'afficher les coefficients binomiaux sous la forme suivante :
p!
C pq =
q!⋅( p − q )!
Développer un sous-programme qui prend en entrée une année et retourne la prochaine année
bissextile.
Réaliser un programme pour le calcul d'intérêts sur un compte bancaire. Un sous-programme prend
en entrée : le capital placé, le taux d'intérêt et la durée du placement en jours. Il retourne l'intérêt
(simple) en Flux.
Réaliser un programme qui permet de diriger un curseur sur 5 champs. Le curseur peut être déplacé
vers la gauche ou vers la droite.
Si le curseur se trouve sur le champs "1", il ne peut pas être déplacé plus vers la gauche. Si le curseur
se trouve sur le champs "5", il ne peut pas être déplacé plus vers la droite.
En cliquant respectivement sur le bouton "<" ou le bouton ">", le curseur est déplacé seulement d'un
champ.
Version du : 30/12/01 20:47 Page 18

Chapitre 4 : Projet de synthèse
4.1. Introduction
Réaliser de façon autonome un projet de synthèse, seul ou en groupe à deux personnes, selon la
disponibilité des ordinateurs. Il s'agit de réaliser un logiciel opérationnel sous Delphi.
Le projet est évalué comme devoir en classe (sur 60 points). Sauf le code source, aucun rapport écrit
est à remettre.
Le projet est à rendre à l'enseignant pour _________________________________ au plus tard.

Copier le projet avec tous les fichiers (sans le fichier exécutable) sur disquette, ou envoyer le par e-
mail.
4.2. Formulation du problème
Il est demandé de développer une calculatrice, permettant d'effectuer les opérations de base
(addition, soustraction, multiplication et division), ainsi que les opérations complémentaires (puissance
y
x , factorielle, carré et racine carré). D'autres fonctions supplémentaires (mémoire, logarithme,
fonctions trigonométriques…) sont considérées comme un bonus dans l'évaluation.
• La calculatrice fonctionne aussi avec des nombres décimales.
• Pour simplifier la réalisation du logiciel, nous définissons la règle

de calcul suivante :
<opérant> <opérateur> <opérant>
Après la touche suivante, que ce soit la touche "=" ou un
opérateur, la calculatrice effectue immédiatement l'expression
entrée préalablement.
Exemple :
L'utilisateur entre : 12 + 4 *
Après le signe "*", la calculatrice affiche 16, même si cela est mathématiquement incorrect,
puisqu'elle devrait attendre l'entrée du troisième nombre, afin d'effectuer d'abord la multiplication.
4.3. Évaluation du projet
• Un programme qui ne fonctionne pas entièrement ou dont certaines des fonctions ne sont pas
implémentées, est considéré comme note insuffisante (note : < 20).
• La note sera suffisante uniquement si toutes les fonctions sont opérationnelles.
• Un programme, dont les algorithmes sont réalisés de façon propre et optimal, et dont l'interface
est attractive, est considéré comme bon travail (note : > 40.
• La propreté et la clarté du code source sont considérées dans l'évaluation.
La recopie d'un programme d'un autre groupe ou la falsification de certaines parties du programme
sont considérées comme faute grave (note : < 10).
L'enseignant effectuera des tests pendant la réalisation du projet et lors de la remise du projet, pour
vérifier si chaque élève dispose de suffisamment de connaissance sur son propre logiciel.
Version du : 30/12/01 20:47 Page 19

4.4. Contraintes
!
• Le projet sera réalisé dans sa totalité à l'école (et non pas à la maison).
• Il est interdit de copier le projet sur disquette.
• Il est interdit d'apporter des disquettes ou de copier par un autre moyen des
informations sur le disque local.
• Toute coopération avec un non-membre du groupe est interdite.
Il est permis d'utiliser toute documentation (livre, Internet…) qui n'est pas en contradiction avec un des
points ci-dessus.
Le projet se trouve dans le répertoire \Calculatrice sur le lecteur personnel (Z:).
4.5. Consignes
• Pour réaliser l'interface, orientez-vous à la calculatrice qui est se trouve sous Windows dans le
menu accessoire.
• Essayer de réutiliser le plus de fonctions qui ont déjà été réalisées pendant l'année (fonction
factorielle, fonction racine carré, fonction puissance…). Cela vous permet de gagner beaucoup de
temps. En plus, vous disposez immédiatement d'un algorithme sans faille.
• Sauvegarder régulièrement votre code source.
• Faire des copies de sauvegarde de votre projet dans un autre répertoire.
Version du : 30/12/01 20:47 Page 20

Chapitre 5 : Les listes et les composants y relatifs

Une variable a en principe un et un seul contenu. De même qu'un objet visuel dispose d'une seule
propriété "Caption" pour afficher un texte. Cependant, Delphi propose un ensemble de composants
qui permettent de stocker plusieurs données à la fois sous forme d'une liste. Nous allons voir ci-
dessous les deux principaux composants, à savoir la "ListBox" et la "ComboBox".
5.1. Les listes dynamiques à accès direct
5.1.1. Introduction
Une liste est un ensemble de lignes, identifiées par un indice. Le contenu d'une ligne est toujours de
type chaîne de caractères (string).
Exemple d'une liste :
0 Didier Bourdon
1 Pascal Légitimus
2
3 Bernard Campan
4
L'indice de la ligne
Le contenu de la ligne
Attention : L'indice commence avec la valeur 0 (et non pas avec la valeur 1).
5.1.2. Caractéristiques
Une liste a deux caractéristiques :

• Une liste est dynamique, c'est-à-dire que le nombre de lignes ne doit pas être spécifié d'avance.
En d'autres termes, il est possible de rajouter des lignes au fur et à mesure.
ième
• Une liste permet un accès direct, c'est-à-dire qu'on peut directement consulter la n ligne. Il
n'est donc pas nécessaire de parcourir toute la liste pour accéder à une certaine ligne. Toute ligne
est identifiée par un numéro, appelé "indice", qui permet d'adresser une ligne particulière.
5.2. Le composant "ListBox"
Description : Le composant du type TListBox permet de créer

une liste standard. Son contenu est toujours du
type chaîne de caractères (string).
Propriétés : Items l'ensemble des lignes, donc le contenu de la liste
ItemIndex retourne l'indice de la ligne sélectionnée, ou –1 si aucune ligne n'a
été sélectionnée
Sorted trier la liste dans l'ordre alphabétique
Méthode : Clear efface le contenu de la liste
Version du : 30/12/01 20:47 Page 21

5.2.1. L'objet TItems
Chaque ligne d'une liste est un objet du type TItems. Le contenu d'une ligne est toujours une chaîne
de caractères. Seulement, il faut indiquer quelle ligne on veut adresser. Pour cela, il faut indiquer
l'indice de la ligne entre crochets.
L'objet Items (et non pas l'objet ListBox) dispose d'un ensemble de méthodes et de propriétés pour
gérer les lignes d'une liste.
Propriété : Count le nombre de lignes disponibles dans la liste
Méthodes : Add ajoute une chaîne de caractère en fin de liste

Insert permet d'insérer une ligne à la position indiquée
Delete supprime la ligne indiquée
LoadFromFile charger le contenu de la liste à partir d'un fichier
SaveToFile sauvegarder le contenu de la liste dans un fichier
5.2.2. Exemples de manipulations de listes
Exemples d'un accès direct à une ligne :

Indice 0 (première ligne)
Indice 4 (cinquième ligne)
Instruction Résultat
S:=ListBox1.Items[0]; S prend la valeur "Didier Bourdon"
S:=ListBox1.Items[4]; S prend la valeur "Pascal Blaise"
Exemple d'un accès direct à la ligne sélectionnée :
Indice 1 (deuxième ligne)
X:=ListBox1.ItemIndex; X prend la valeur 1 (l'indice de la ligne sélectionnée)
S:=ListBox1.Items[X]; S prend la valeur "Pascal Légitimus"
Exemples d'utilisation des méthodes :
ListBox1.Clear; Efface tout le contenu de la liste.
Rajoute la chaîne de caractère "José" à la
ListBox1.Items.Add('José');
fin de la liste.
Insère la chaîne de caractère "Teresa" à la
ListBox1.Items.Insert(2,'Teresa');
position 2 de la liste
ListBox1.Items.Delete(3); Supprime la quatrième ligne de la liste
Sauvegarde tout le contenu de la liste dans
ListBox1.Items.SaveToFile('T.txt')
le fichier "T.txt".
Chargement du contenu de la liste à partir
ListBox1.Items.LoadFromFile('T.txt')
du fichier "T.txt".
Version du : 30/12/01 20:47 Page 22

5.3. Exercices
Réaliser un programme qui permet de gérer une

liste des élèves.
• Prévoir une zone pour entrer le nom d'un
élève et de l'ajouter dans une liste.
• Si on click sur un élève dans la liste, ce nom
est affiché dans un "label".
• Il est possible de supprimer un élève
sélectionné de la liste.
• Permettre d'effacer toute la liste.
• Il est possible de trier la liste dans l'ordre
alphabétique.
Extensions possibles :
• Ne pas ajouter une ligne vide si l'utilisateur
n'entre aucun nom.
• Permettre de sauvegarder la liste dans un
fichier.
• Permettre de charger la liste à partir d'un
fichier.
• Permettre d'insérer un nom dans à la position
sélectionnée.
Développer un programme qui permet de calculer la somme des

nombres dans une liste.
• En cliquant sur un bouton, la liste est remplie avec 10 nombres
aléatoires entre 1 et 20. Chaque prochain click sur ce bouton
rajoute 10 nombres aléatoires à la liste.
• Un bouton "Somme" calcul et affiche la somme des nombres de la
liste.
• L'utilisateur peut entrer la limite inférieure et la limite supérieure
des nombres aléatoires à générer.
• Prévoir un mécanisme pour assurer que la limite inférieure soit
toujours plus petite que la limite supérieure.
• L'utilisateur peut indiquer le nombre de nombres aléatoires à insérer.
• Prévoir une possibilité pour effacer la liste et pour redémarrer le programme.
Version du : 30/12/01 20:47 Page 23

Développer un programme pour réaliser des statistiques comme le montre la figure ci-dessous.
Contraintes :
• Seulement des nombres entre 1 et 100 sont acceptées est rajoutées dans le tableau. Sinon, le
programme affiche un message approprié dans une fenêtre de dialogue (MessageDlg).
• Quand la liste est vide, les boutons "Calculer" et "Vider" ne sont pas actifs.
• Le bouton "Calculer" permet d'afficher une statistique sur le contenu du tableau. Si une nouvelle
valeur est rajoutée dans la liste, la statistique qui se trouve éventuellement encore affichée, est
effacée.
• Le bouton "Vider" supprime tout le contenu de la liste est, le cas échéant, efface la statistique.
• Le bouton "Fin" termine le programme.
• Rajouter une option pour ajouter un nombre aléatoire dans la liste.
• L'utilisateur peut entrer la limite inférieure et la limite supérieure des nombres aléatoires à générer.
• Prévoir un mécanisme pour assurer que la limite inférieure soit toujours plus petite que la limite
supérieure.
• L'utilisateur peut indiquer le nombre de nombres aléatoires à insérer.
• Prévoir une possibilité pour effacer la liste et pour redémarrer le programme.
Version du : 30/12/01 20:47 Page 24

Réaliser un programme qui permet de gérer une liste des membres d'un club.
• L'utilisateur peut remplir une liste avec des noms.
• Il est possible de trier la liste dans l'ordre alphabétique.
• Prévoir un mécanisme pour effacer un nom de la liste (en cliquant sur un bouton "supprimer").
• En double-cliquant sur un nom, celui-ci peut être modifié. Le nom à modifier est d'abord copié
dans une zone d'édition (Edit), où il peut être modifié. Ensuite, il est automatiquement supprimé
de la liste. Pour valider la modification, l'utilisateur actionne un bouton. Le texte modifié est ensuite
rajouté à la liste.
• Une statistique affiche combien de fois un certain nom apparaît dans la liste. Le nom à rechercher
est entré dans une zone d'édition (Edit).
• Il est possible de remplacer toutes les occurrences d'un certain nom dans la liste par un autre
nom. Le nombre de remplacements est affiché.
• Prévoir un mécanisme pour supprimer toutes les occurrences d'un certain nom.
• Permettre de "désactiver" la fonction de tri.
• Il est possible de sauvegarder et de charger le contenu de la liste.
Version du : 30/12/01 20:47 Page 25

Remplir une première liste avec N nombres aléatoires entre 2 et 5. N étant un nombre entré par
l'utilisateur.
En appuyant sur un bouton, une deuxième liste est remplie avec la factorielle correspondante au
nombre de la première liste. Réutiliser la fonction FAC(N) réalisée au premier trimestre !
Soit deux listes (liste A et liste B). Chacune contient des nombres aléatoires entre 10 et 20. Copier
tous les éléments de A vers B, sachant que l'utilisateur peut indiquer une valeur qui n'est pas à copier.
Mémoriser les résultats de x jets d'un dé, où x est un nombre entré par l'utilisateur (utiliser un
"SpinEdit"). Une statistique peut être demandée, qui affiche le nombre de fois, que chacun des 6
chiffres est apparu dans le résultat.
Remplir une liste avec N nombres aléatoires. L'utilisateur détermine les limites de ces nombres.
Afficher dans une deuxième liste le contenu de la première ainsi que les positions.
Déterminer le nombre d'éléments paires d'une liste.
Fusionner deux listes A et B, triés par ordre croissant, en une seule liste C, trié par ordre croissant.
suite 1 : 5 7 10 12 13 13 16 suite 2 : 2 3 9 12
Transférer les nombres strictement positifs d'une liste A dans une liste B, et les nombres négatifs ou
nuls dans une liste C.
Version du : 30/12/01 20:47 Page 26

5.4. Le composant "ComboBox" (français : boîte à options)
Description : Un composant TComboBox est l'association des

caractéristiques d'une zone d'édition (TEdit) avec
celles d'une liste (TListBox).
La zone d'édition montre l'élément sélectionné
dans la liste déroulante sous-jacente.
Propriétés : Items l'ensemble des lignes, donc le contenu de la liste (voir ListBox)
Sorted trier la liste dans l'ordre alphabétique
Text le texte qui se trouve dans la boîte de saisie
En général, la boîte à options est manipulée comme une liste (ListBox), sauf qu'elle dispose d'une
boîte de saisie. Les lignes de la boîte à options sont, par analogie à la "ListBox", du type "TItems". Le
chargement et la sauvegarde du contenu de la liste se fait donc de la même façon comme pour la
"ListBox".
5.4.1. Style d'une "ComboBox"
Il existe trois boîtes à options standard. Le style est défini par la valeur de la propriété "Style".
Constante Signification
csSimple La liste déroulante n'est pas visible, mais les éléments sont accessibles
par les touches curseur.
csDropDown La liste déroulante apparaît lorsqu'on clique sur le bouton fléché. La
zone d'édition est accessible. C'est le style par défaut.
csDropDownList La zone d'édition n'est pas accessible. La liste déroulante s'ouvre
automatiquement lorsqu'on clique sur la boîte à options.
Deux autres styles sont "csOwnerDrawFixed" et "csOwnerDrawVariable". Ils permettent de définir des
boîtes à options non-standard.
Réaliser un programme qui permet à l'utilisateur de choisir un mois à partir d'une liste. Le mois
sélectionné sera affiché dans un label.
• Le contenu de la liste peut être chargé à partir du fichier "mois.dat".
• Essayer les trois styles (csSimple, csDropDown, csDropDownList) pour la boîte à option.
Reprendre les exercices sur les listes et les modifier de sorte en utilisant que des boîtes à options (si
possible).
Version du : 30/12/01 20:47 Page 27

Réaliser le programme représenté par l'interface ci-dessous.
Partie 1 : Saisie
a) Mettre en œuvre la description des objets suivante :
speL1 speL2 speN
minValue ! 0 minValue ! 1 minValue ! 1
maxValue ! 10 maxValue ! 20 maxValue ! 99
Value ! 0 Value ! 5 Value ! 1
b) Le bouton Remplir remplit la première liste

avec N nombres aléatoires compris entre L1
et L2. Cependant, si la limité inférieure est
plus grande que la limite supérieure, le
message suivant est affiché :
c) Réaliser une fonction ALEATOIRE(N1,N2)

qui retourne un nombre aléatoire compris entre les deux limites indiquées.
d) Le bouton Fin termine le programme.
Partie 2 : Liste entrée

a) Le bouton Charger remplit la première liste à partir du fichier "donnees.dat".
b) Le bouton Enregistrer sauvegarde le contenu de la liste dans le fichier "donnes.dat".
c) Le bouton Effacer supprime tout le contenu de la première liste.
Partie 3 : Liste résultat

a) La boîte à option (ComboBox) permet de sélectionner une des opérations suivantes : factorielle,
carré, racine.
b) Le contenu de la deuxième liste est vidé, si l'utilisateur fait un choix dans la boîte à option.
c) Le bouton Calculer remplit la deuxième liste en appliquant l'opération sélectionnée (dans la
boîte à option) avec les nombres de la première liste. Ré-utiliser la fonction ROUND pour arrondir
les nombres à 2 positions décimales pour le calcul de la racine.
Consulter le programme exécutable pour apprendre à quel moment les différents boutons sont
respectivement actifs ou pas actifs.
Version du : 30/12/01 20:47 Page 28

Chapitre 6 : Les opérations sur les chaînes de caractères
6.1. Introduction
Une chaîne de caractère est appelée "string" en Delphi (et Pascal). On peut considérer une chaîne de
caractère comme liste de caractères.
Chaîne de caractères : "Salut"
Représentation sous forme de liste : S

En Pascal :
a …
var S:string;
l …
S:='Salut';
u …
t
Attention : la première cellule porte l'indice 1 (et non pas 0, comme chez les listes).
6.2. Opérations avec les chaînes de caractères
6.2.1. Concaténation de chaînes de caractères
Deux textes peuvent être "additionner". En parle de

concaténation de chaînes de caractères.
L'exemple ci-dessous additionne les deux textes et affiche le

résultat dans un panel. Remarquer que les deux textes ne
sont pas automatiquement séparés par un espace.
Voici le code source pour le bouton "Concaténation" :
procedure TForm1.btnConcatenationClick(Sender: TObject);

begin
pnlAffiche.Caption:=edt1.Text+edt2.Text
end;
Remarque : Pour insérer un espace entre "Delphi" est "is fun", il suffit d'écrire :
procedure TForm1.Button1Click(Sender: TObject);

begin
pnlAffiche.Caption:=edt1.Text+' '+edt2.Text
end;
6.2.2. Longueur d'une chaîne de caractères
Rappelant qu'une liste est dynamique, c'est-à-dire que sa longueur n'est pas connue d'avance. Par
analogie, la longueur d'une chaîne de caractère n'est pas connue. L'instruction Length retourne la
longueur, c'est-à-dire le nombre de lettres, d'une chaîne de caractères.
Exemple :
Soit la chaîne de caractères X :
Affectation de la variable S Length(S)

S ! "ABCD" 4
S ! "12" 2
S ! "" 0
Version du : 30/12/01 20:47 Page 29

6.3. Extraction d'une sous-chaîne d'une chaîne de caractères
L'instruction Copy retourne la sous-chaîne d'une chaîne de caractères.
En général :
S ! Copy(CHAINE, I, NBR)
nombre de caractères
une chaîne de caractères à extraire
la position à partir de
laquelle on veut extraire
une sous-chaîne
Exemples :
Soit PHRASE une chaîne de caractères contant le texte : "Je me sens en forme".
Instruction d'extraction Contenu de S

S ! Copy(PHRASE,3,2)
S ! Copy(PHRASE,1,5)
S ! Copy(PHRASE,1,Length(PHRASE))
6.4. Exercices
Écrire un programme qui lit une chaîne de caractères à

partir d'une boîte de saisie (TEdit) et l'affiche dans le sens
opposé.
Écrire une fonction PALINDROME(S:string):boolean

qui vérifie si S est un palindrome (un mot qui peut se lire
du début vers la fin, ou de la fin vers le début, sans
changer de sens).
Exemples :
Salut " non
RADAR " oui
omo " oui
otto " oui
• Lire une chaîne de caractères S.

• Lire un caractère C (une chaîne à longueur 1).
• Supprimer toutes les occurrences de C dans S.
• Afficher le mot qui en résulte, ainsi que le nombre de
suppressions.
Version du : 30/12/01 20:47 Page 30

• Lire une chaîne de caractères S.

• Lire un caractère C1 et un caractère C2.
• Remplacer toutes les occurrences de C1 avec C2 dans S.
• Lire une chaîne de caractères S1.

• Lire une chaîne de caractères S2
• Compter combien de fois S2 apparaît dans S1.
Séparer le prénom et le nom à partir d'une seule chaîne.
Travail à faire :
• Réaliser une présentation identique à celle montrée dans la figure.
• La zone d'édition de la boîte à options (ComboBox) n'est pas accessible.
• Au moment du démarrage du programme, le contenu de la boîte à options est automatiquement
chargé à partir du fichier "usa.dat".
• En sélectionnant un élément de la liste, le nom et le prénom duquel se compose cette chaîne de
caractères sont automatiquement séparés.
• Écrire un programme qui permet d'afficher dans le sens opposé une liste de noms.
• Le bouton "Charger" permet de charger des noms à partir du fichier "noms.dat".
• Le bouton "Inverser" ajoute tous les noms dans le sens opposé dans la deuxième liste, en utilisant
une fonction INVERSER(S:string):string.
• Le bouton "Effacer" supprime le contenu de la deuxième liste (noms renversés).
• Consulter le programme exécutable pour apprendre le jeu des boutons (quel bouton est actif à
quel moment).
Version du : 30/12/01 20:47 Page 31

Afficher la fréquence d'un caractère

donné dans une chaîne donnée.
Afficher la fréquence de tous les
caractères dans une chaîne donnée.
Réaliser la fonction
FREQUENCE(TEXTE:string;
S:string):integer
qui retourne le nombre de fois le

caractère S se trouve dans la chaîne
TEXTE.
On donne une chaîne de caractères et une liste de

N caractères. Déterminer le nombre d'occurrences
de chacun de ces caractères dans la chaîne
donnée.
Décomposer une chaîne de caractères en ses

mots. Nous supposons que chaque mot est
séparé par un seul espace.
• Les mots de la chaîne de caractères
peuvent être séparés d'un ou de plusieurs
espaces.
• Les mots de la chaîne de caractères
peuvent être séparés par d'autres
symboles (p. ex. virgule, points,…).
L'utilisateur peut définir la liste de
séparateurs.
Version du : 30/12/01 20:47 Page 32

Compter le nombre de mots d'une phrase donnée.
Déterminer le plus long mot d'une phrase donnée.
Soit une liste de nombres aléatoires entre –10 et +10. Réaliser une méthode qui permet de transférer
les nombres positifs dans une deuxième liste et les nombres négatifs dans une troisième liste.
6.4.14. Exercice C6E13 #

Soit L1 une liste de nombres aléatoires entre 2 et X (X étant une valeur entrer par l'utilisateur).
• Copier toutes les valeurs de L1 qui sont des nombres premiers dans une liste L2.
• Copier toutes les valeurs de L1 qui sont des nombres parfaites dans une liste L3. (Un nombre est
parfait si la somme de ses diviseurs donne le nombre lui-même.)

Soit la suite suivante :
1
11
21
1211
111221
Écrire un programme qui calcule la ligne suivante et la rajoute dans une liste. À chaque fois, où
l'utilisateur appuie sur un bouton, la prochaine ligne sera dérivée de la précédente.

Fusionner deux listes de chaînes de caractères triées en une seule liste triée.

Effectuer une recherche dichotomique d'une chaîne de caractères, entrée par l'utilisateur, dans une
liste triée de chaînes données.

Écrire un programme qui permet de trier une liste de nombres dans l'ordre croissant.
L'utilisateur peut choisir à l'aide d'une boîte à option, si la liste doit être triée dans l'ordre croissant ou
décroissant.
Version du : 30/12/01 20:47 Page 33

Chapitre 7 : Les menus et les composants relatifs
7.1. Le menu principal
Description : Le composant du type TMenu permet de créer un

menu principal. L'objet proprement dit est
invisible.
Propriété : Items l'ensemble des menus
7.1.1. Création d'un menu
La propriété "Items" de l'objet "MainMenu" permet d'activer une fenêtre pour saisir les différents sous
menus. L'entrée du caractère "-" permet d'insérer une ligne dans le menu actuel.
7.1.2. L'objet TMenuItem
Chaque option dans le menu est en fait un objet du type TMenuItem. Dans l'exemple ci-dessus,
Delphi a crée les objets "File1", "Open1", "Save1" et "Saveas1". Ces objets ne sont pas visibles
sur la fiche, mais peuvent être modifiés dans l'inspecteur des objets.
Propriétés : Caption le nom du menu

Checked cocher le menu
Enabled le menu est actif ou non
ShortCut combinaison de touches pour directement activer cette option
Événement : OnClick sélectionner ce menu (avec la souris ou avec le "ShortCut")
Remarque : L'événement OnClick peut très bien pointer sur une méthode déjà existante. Cela se
fait souvent en pratique, d'offrir à l'utilisateur un menu complet, mais aussi quelques
boutons qui regroupent les fonctions essentielles du programme. L'utilisateur a alors
le choix d'actionner le bouton ou le menu, voire même d'utiliser un ShortCut.
Version du : 30/12/01 20:47 Page 34

7.2. Les dialogues
Beaucoup d'occasions sont imaginables, où l'utilisateur est demandé d'entrer certaines informations
(par exemple : choix de l'imprimante, choix de la police de caractère, choix du nom de fichier,…). De
tels dialogues sont standardisés en Windows, donc existent sous forme de composants en Delphi. Ci-
dessous, nous nous limitons sur l'explication du dialogue de sauvegarde et du dialogue d'ouverture.
7.2.1. Le dialogue de sauvegarde
Description : TSaveDialog affiche une fenêtre de dialogue pour

sélectionner le nom d'un fichier à sauvegarder.
Cette fenêtre devient seulement visible au
moment de l'appel.
Propriété : FileName le nom du fichier sélectionné
Méthode : Execute exécution du dialogue avec ouverture de la fenêtre
Remarque : Il est possible de tester si l'utilisateur a choisi un nom de fichier, ou s'il a appuyé sur
le bouton "cancel".
Exemple :
if SaveDialog1.Execute=false then
MessageDlg('Cancel',mtInformation,[mbOk],0)
else
Memo1.Lines.SaveToFile(SaveDialog1.FileName);
7.2.2. Le dialogue d'ouverture
Description : TOpenDialog affiche une fenêtre de dialogue

pour sélectionner le nom d'un fichier à ouvrir.
Cette fenêtre devient seulement visible au
moment de l'appel.
Propriété : FileName le nom du fichier sélectionné
Méthode : Execute exécution du dialogue avec ouverture de la fenêtre
Remarque : Il est possible de tester si l'utilisateur a choisi un nom de fichier, ou s'il a appuyé sur
le bouton "cancel".
Exemple :
if OpenDialog1.Execute=false then
MessageDlg('Cancel',mtInformation,[mbOk],0);
Version du : 30/12/01 20:47 Page 35

Chapitre 8 : Projet de synthèse
8.1. Introduction
Réaliser de façon autonome un projet de synthèse, seul ou en groupe à deux personnes, selon la
disponibilité des ordinateurs. Il s'agit de réaliser un logiciel opérationnel sous Delphi.
Le projet est évalué comme devoir en classe (sur 60 points). Sauf le code source, aucun rapport écrit
est à remettre.
Le projet est à rendre à l'enseignant pour _________________________________ au plus tard. Co-

pier le projet avec tous les fichiers (sans le fichier exécutable) sur disquette, ou envoyer le par e-mail.
8.2. Formulation du problème
Il est demandé de développer un logiciel qui permet de gérer des championnats de Taekwondo.
Le Taekwondo est un art martial coréen et un sport olympique.

Les tournois (de combat) sont organisés en catégories de poids. Les compétiteurs sont
regroupés selon leur sexe et leur poids.
Étape 1 : Lecture des données

• L'utilisateur, par exemple l'organisateur du championnat, peut ouvrir un fichier des compétiteurs. Ce
fichier a la structure suivante : <nom du compétiteur> ; <poids> ; <sexe>
Par exemple :
competiteurs.dat
Bruce Lee;65;M
Chuck Norris;78;M
Jackie Chan;68;M
Master Lee;72;M
• L'utilisateur peut sélectionner un fichier de données à l'aide d'un dialogue.

• Utiliser une liste temporaire (lbTemp) qui contiendra la liste des compétiteurs. Séparer ensuite le
nom, le poids et le sexe respectivement dans une liste d'édition (cbNoms) et dans des listes
normales (lbPoids et lbSexe).
Étape 2 : Modification des données d'un compétiteur

• L'utilisateur peut sélectionner un compétiteur. Les données sur ce compétiteur sont ensuite affichées
dans des zones d'édition.
• Le bouton "Valider" confirme les modifications apportées.
• Le menu "Fichier – Enregistrer" permet de sauvegarder les informations sur les compétiteurs. En
fait, il faut d'abord créer la liste "lbTemp" des compétiteurs avec la structure expliquée ci-dessus.
Cette liste sera ensuite sauvegardée (utiliser une fenêtre de dialogue pour permettre à l'utilisateur de
choisir un nom de fichier).
Étape 3 : Génération des catégories de combat

• Il est possible de sélectionner une des cinq catégories, ainsi que la catégorie de sexe, et le
programme affiche tous les compétiteurs concerncés.
8.3. Évaluation du projet
• Un programme qui ne fonctionne pas entièrement ou dont certaines des fonctions ne sont pas
implémentées, est considéré comme note insuffisante (note : < 20).
• La note sera suffisante uniquement si toutes les fonctions sont opérationnelles.
Version du : 30/12/01 20:47 Page 36

• Un programme, dont les algorithmes sont réalisés de façon propre et optimale, et dont l'interface
est attractive, est considéré comme bon travail (note : > 40).
• Des fonctionnalités supplémentaires sont considérées comme bonus, mais ne sont cependant pas
nécessaire pour obtenir une note positive.
• La propreté et la clarté du code source sont considérées dans l'évaluation.
La recopie d'un programme d'un autre groupe ou la falsification de certaines parties du programme
sont considérées comme faute grave (note : < 10).
L'enseignant effectuera des tests pendant la réalisation du projet et lors de la remise du projet, pour
vérifier si chaque élève dispose de suffisamment de connaissances sur son propre logiciel.
8.4. Contraintes
• Le projet sera réalisé dans sa totalité à l'école (et non pas à la maison).
•
Il est interdit de copier le projet sur disquette.
Il est interdit d'apporter des disquettes ou de copier par un autre moyen des
informations sur le disque local.
Toute coopération avec un non-membre du groupe est interdite.

!
Il est permis d'utiliser toute documentation (livre, Internet…) qui n'est pas en contradiction avec un des
points ci-dessus.
Le projet se trouve dans le répertoire 12GE1\Championnat sur le lecteur partagé.
8.5. Consignes
• Il est conseillé de
s'orienter au programme
exécutable pour réaliser
l'interface graphique.
• Préparer les algorithmes

sur papier
(structogramme).
• Réaliser une étape après

l'autre.
• Sauvegarder
régulièrement le code
source.
• Faire des copies de

sauvegarde du projet
dans un autre répertoire.
Version du : 30/12/01 20:47 Page 37

Chapitre 9 : Les composants d’animation
9.1. Le composant "Timer"
Description : Les composants du type TTimer sont invisibles

pendant l'exécution du programme. Les objets de
ce type sont utilisés pour exécuter des actions à
intervalles réguliers.
Propriété : Interval détermine la périodicité des événements OnTimer, intervalle de

temps en millisecondes (entier 0…65535)
Événement : OnTimer Événement activé après l'écoulement de l'intervalle défini (sauf si le

composant est désactivé)
9.1.1. Exercice C9E1 : "Chrono"
La fiche contient trois boutons ("Up", "Reset'" et "Automatic'") et un panel affichant d'abord la valeur
zéro.
• Par le bouton "Up'" la valeur du panel est augmentée de 1.
• Le bouton "Reset" remet le compteur à zéro.
• Par le bouton "Automatic'" la valeur du panel est augmentée de 1 chaque seconde. Le bouton
"Up" est désactivé. En cliquant sur "Reset" le mode automatique est arrêté et le bouton "Up" est à
nouveau activé.
• Prévoir un bouton "Down" qui diminue la valeur du panel de 1. Attention, dans le mode
automatique, il faut vérifier s'il faut augmenter ou diminuer la valeur du panel.
• Modifier le programme de façon à ce que la valeur du compteur soit augmentée et diminuée par
une valeur entrée dans un champ d'édition.
• Prévoir un mécanisme pour que l'utilisateur puisse modifier la fréquence (par défaut : 1 seconde).
9.1.2. Exercice C9E2 : "Animation"
Les composants visibles disposent de deux propriétés intéressantes : "top" et "left". Elles indiquent la
position de l'objet par rapport au bord de la fiche. En se servant de ces deux propriétés, il est
demandé de réaliser le programme suivant :
• Un panel se déplace automatiquement de la gauche vers la droite sur la fiche (utiliser un
composant Timer). Le sens du déplacement du panel change dès que l'image touche au bord de
la fenêtre.
• Intégrer un champ d'édition pour modifier le pas de déplacement du panel.
• Intégrer un champ d'édition pour modifier l'intervalle du Timer.
• Les deux champs d'édition sont regroupés dans une "GroupBox".
• La couleur du texte du panel change de façon aléatoire à chaque déplacement.
• Deux boutons "Left" et "Right" permettent de changer de sens manuellement. Une logique
appropriée est utilisée afin que seulement un des deux boutons soit actif à la fois.
• Modifier l'exercice en ralentissant l'image progressivement lorsqu'elle s'approche des bords de la
fenêtre avant de modifier la direction. (utiliser les fonctions trigonométriques sin ou cos).
Version du : 30/12/01 20:47 Page 38

9.2. Le composant "Image"
Description : Le composant du type TImage sert à afficher une

image ou une icône dans le formulaire. Différents
types d'images sont supportés.
Propriétés : Autosize dés/activation de l'adaptation automatique de la surface d'affichage

aux dimensions originales de l'image
Stretch adaptation de la taille de l'image au cadre prévu (attention : l'image
sera déformée)
Picture l'image proprement dite
Remarque : La propriété picture est un objet du type TPicture qui dispose entre autre de la
méthode LoadFromFile pour charger une image.
Exemple :
Image1.Picture.LoadFromFile('c:\images\lte.jpg');
• La fiche contient deux boutons portant les titres 'Hide' et 'Show' ainsi qu'un composant Image1 du
type TImage.
• Une image est à charger dans Image1. Le cadre de l'image doit s'adapter automatiquement à la
taille de l'image, sans la modifier.
• Les boutons 'Hide' et 'Show' respectivement cachent ou fassent réapparaître l'image.
• Seulement un des boutons 'Hide' et 'Show' est visible à la fois.
• À l'aide de cinq boutons ('Image 1'…'Image 5'), l'utilisateur peut choisir l'image qui sera affichée.
• Prévoir un mécanisme pour que l'utilisateur puisse décider si le cadre de l'image doit s'adapter à
la taille de l'image ou non.
Les images 'pic1.jpg' jusqu'à 'pic5.jpg' se trouvent dans le répertoire de travail. Réaliser le programme
suivant :
• Le bouton 'Start' active un Timer qui affiche à intervalle régulier successivement les différentes
images. Le bouton 'Stop' et 'Start' ne sont pas actifs en même temps.
• L'intervalle de temps peut être sélectionné en cours de route (minimum : 1 seconde et maximum :
5 secondes).
• Le nombre d'images à montrer peut être changé en cours d'exécution.
• L'image est automatiquement adaptée à la dimension du cadre prévu (utiliser la propriété stretch).
• Le bouton 'Fin' termine le programme.
Version du : 30/12/01 20:47 Page 39

Version du : 30/12/01 20:47 Page 40

9.3. Utilisation des fonctions pour faire des tests
Une fonction est un sous-programme qui retourne une valeur. Cette valeur peut être un nombre, une
chaîne de caractère, mais peut aussi être du type logique : vrai ou faux (en Delphi : true, false). Ce
dernier type, appelé "boolean" est idéal pour retourner le résultat d'un test.
9.3.1. Exemple
Il est demandé de compter les nombres premiers dans

une liste de nombres. La solution idéale serait de réaliser
un sous-programme (ici : une fonction) qui vérifie un
nombre. Appelons ce sous-programme :
TEST_PREM(X)
Ce sous-programme réalise tout le traitement

nécessaire, afin de tester si le nombre qu'on lui a
transmis comme paramètre (dans l'exemple : X), est un
nombre premier ou non. Le résultat logique de ce test
(nombre premier : oui ou non), est retourné.
Dans une structure alternative, le programme appelant le

sous-programme, peut ainsi incrémenter un compteur à
chaque fois, où la fonction retourne un résultat vrai.
TEST_PREM(X) = true
vrai faux
"nombre premier" "pas nombre premier"
Voici la solution complète :
Button1.onClick TEST_PREM(X)
I ! 0 I ! 2
C ! 0
tant que (I <= X) et (X mod I <> 0)
tant que I <= ListBox1.Items.Count-1
I ! I + 1
X ! StrToInt(ListBox.Items[I])
X mod I <> 0
TEST_PREM(X) = true vrai faux
vrai faux
TEST_PREM ! true TEST_PREM!false
C ! C + 1
I ! I + 1
Panel2.Caption ! IntToStr(C)
Version du : 30/12/01 20:47 Page 41

unit Unit1;
… procedure TForm1.Button1Click(Sender:
… TObject);
… var I,C,X:integer;
begin
implementation I:=0;
C:=0;
{$R *.DFM} while I<=ListBox1.Items.Count-1 do
begin
function TEST_PREM(X:integer):boolean; X:=StrToInt(ListBox1.Items[I]);
var I:integer; if TEST_PREM(X)=true then
begin begin
I:=2; C:=C+1;
while (I<=sqrt(I)) and (X mod I<>0) do end;
begin I:=I+1;
I:=I+1; end;
end; Panel2.Caption:=IntToStr(C);
if X mod I<>0 then end;
begin
TEST_PREM:=true; end.
end
else
begin
TEST_PREM:=false;
end;
end;
Réaliser un programme qui permet d'effectuer une expression numérique contenant deux termes.
L'opérateur (addition, soustraction, division, multiplication, exposant) est à choisir dans une liste
d'édition.
Travail à faire :
• Réaliser une interface identique à celui montré ci-dessus.
• Choisir le type de la liste d'édition, de façon à ce que l'utilisateur ne puisse pas entrer une valeur
dans la zone d'édition de la liste.
• Le bouton "=" fait évaluer l'expression en vérifiant :
– d'abord si les deux termes ne contiennent seulement des chiffres, ou éventuellement le signe
"+" ou "-" au début du terme, sinon un message d'erreur est affiché dans une fenêtre de
dialogue (MessageDlg) ;
– si l'utilisateur a vraiment choisi un opérateur.
• Dans le cas de l'opérateur "^", un sous-programme réalise ce traitement. L'exposant négatif ou nul
est accepté aussi.
Version du : 30/12/01 20:47 Page 42


ième
Réaliser un programme qui permet d'effectuer une expression à une inconnue et du n degré.
Travail à faire :
• L'utilisateur entre une expression correcte.
• Chaque terme est toujours précédé par un signe (+ ou -), même le premier terme.
• Chaque terme a un degré (l'exposant est séparé du coefficient par le symbole ^).
• Le degré n'a pas de signe.
• Le degré 0 est permis.
• Un terme et un degré se compose de 1 ou plusieurs chiffres.
• Utiliser une fonction "EXP" qui calcul la puissance x .
y
Réaliser un programme qui permet de résoudre une équation du premier degré à une inconnue.
Travail à faire :
• L'utilisateur entre une expression correcte (l'inconnue étant toujours "x").
• Chaque terme est toujours précédé par un signe (+ ou -), même le premier terme.
• Réaliser une fonction "TRANSPOSE(S,MEMBRE)", où S est l'expression (par exemple : le membre
de gauche) sous forme de chaîne de caractères, et MEMBRE est l'information, s'il s'agit du membre
de gauche ou de droite.
• Isoler chaque terme.
• Mettre les coefficients dans une liste et les constantes dans une autre. Attention au changement
de signe, si un terme est transposé de membre.
Version du : 30/12/01 20:47 Page 43

Il est demandé de réaliser un dictionnaire : "Français – Allemand".
Remarque préliminaire :
Un mot français peut avoir une, deux ou trois traductions.
Étape 1 : Chargement
Au moment du démarrage du programme, le vocabulaire est chargé. Sur le disque se trouve un fichier
"DICO.DAT" qui a la structure suivante :
abaisser;senken
abandonner;verlassen;aufgeben
abattoir;Schlachthof
abri;Schutz;Obdach;Bunker
abruti;Blödian
Ce fichier peut être lu dans une liste.
Étape 2 : Présentation
Le dictionnaire se présente sous forme de quatre listes.
• La première contient le mot français.
• La deuxième la traduction en allemand.
• La troisième et quatrième liste contient une autre traduction si disponible. Sinon, elles ont le
contenu : "---".
Étape 3 : Recherche
Il est possible de rechercher un mot français dans le dictionnaire.
• Si le mot est introuvable, un message approprié est affiché.
• Si le mot a été trouvé, les lignes correspondantes dans les quatre listes sont sélectionnées.
Utiliser un algorithme de recherche au choix.
Version du : 30/12/01 20:47 Page 44

Réaliser un programme qui calcule le sinus, le cosinus et la tangente de certains angles.
Remarques préliminaires :
• Une fonction "tangente" n'existe pas en Delphi.
• Delphi est un produit américain, donc travaille avec des radians pour exprimer des angles (et non
pas des degrés).
X1
X2
Étape 1 : Saisie
• Une liste peut être remplie avec N nombres aléatoires entre X1 et X2.
• X1 et X2 peuvent varier entre 0 et 360. N peut varier entre 0 et 20.
• Si X1 est plus grand que X2, alors le programme fait automatiquement une permutation.
• La liste est vidée avant de la remplir avec de nouvelles valeurs.
Étape 2 : Calculer
• Utiliser une fonction CONV pour convertir les angles en radians.
• Développer une fonction TAN pour calculer la tangente d'un angle (exprimé en radians).
• La fonction TAN retourne "---" si la tangente n'existe pas, sinon une valeur.
• Les listes sont vidées avant de les remplir avec de nouvelles valeurs.
Divers
• Le bouton "Calculer" est seulement actif, après avoir appuyer sur la touche "Remplir".
• Le bouton "Calculer" se desactif après l'avoir actionner.
• Le bouton "Auteur" affiche le nom du programmeur dans une fenêtre.
Version du : 30/12/01 20:47 Page 45

Table des matières
CHAPITRE 1 : L'APPROCHE OBJET .........................................................................................................................2

1.1. INTRODUCTION .........................................................................................................................................................2
1.2. EXEMPLE : ANALYSE DE L'OBJET _________________________............................................................................2
1.2.1. Description........................................................................................................................................................2
1.2.2. Actions possibles ...............................................................................................................................................2
1.2.3. Représentation graphique .................................................................................................................................3
1.2.4. Événements........................................................................................................................................................3
1.3. CYCLE DE DEVELOPPEMENT......................................................................................................................................3
1.3.1. Analyse orientée objet .......................................................................................................................................3
1.3.2. Conception orientée objet .................................................................................................................................3
1.3.3. Programmation orientée objet ..........................................................................................................................3
CHAPITRE 2 : L'ENVIRONNEMENT DELPHI .........................................................................................................4
2.1. PRESENTATION .........................................................................................................................................................4
2.2. VU SUR LES COMPOSANTS DE BASE DE DELPHI .........................................................................................................4
2.2.1. Le composant "Panel".......................................................................................................................................4
2.2.2. Le composant "Button" .....................................................................................................................................4
2.2.3. Le composant "EditBox" ...................................................................................................................................5
2.2.4. Le composant "ListBox" ....................................................................................................................................5
2.2.5. Le composant "ComboBox" ..............................................................................................................................5
2.2.6. Autres composants ............................................................................................................................................5
2.3. CONVENTIONS DE DENOMINATION ............................................................................................................................5
2.4. L'INSPECTEUR D'OBJETS ............................................................................................................................................6
2.4.1. La manipulation des propriétés.........................................................................................................................7
2.4.2. La manipulation des méthodes..........................................................................................................................7
2.5. EXERCICES ................................................................................................................................................................8
2.5.1. Exercice C2E1...................................................................................................................................................8
2.5.2. Exercice C2E2...................................................................................................................................................8
2.5.3. Exercice C2E3...................................................................................................................................................8
2.5.4. Exercice C2E4...................................................................................................................................................8
2.6. CONVERSIONS DE TYPES ...........................................................................................................................................9
2.7. EXERCICES ................................................................................................................................................................9
2.7.1. Exercice C2E5...................................................................................................................................................9
2.7.2. Exercice C2E6...................................................................................................................................................9
2.7.3. Exercice C2E7...................................................................................................................................................9
2.7.4. Exercice C2E8.................................................................................................................................................10
2.7.5. Exercice C2E9.................................................................................................................................................10
2.7.6. Exercice C2E10...............................................................................................................................................10
2.7.7. Exercice C2E11...............................................................................................................................................11
CHAPITRE 3 : LES SOUS-PROGRAMMES .............................................................................................................12
3.1. INTRODUCTION .......................................................................................................................................................12
3.2. LES NOTIONS DE BASES ...........................................................................................................................................12
3.2.1. Modularité.......................................................................................................................................................12
3.2.2. Réutilisation ....................................................................................................................................................12
3.3. COMPARAISON : SOUS-PROGRAMME ET METHODE ..................................................................................................12
3.3.1. Différences ......................................................................................................................................................12
3.3.2. Égalités............................................................................................................................................................12
3.3.3. La notation ......................................................................................................................................................13
3.4. LES FONCTIONS (DELPHI : FUNCTION) .....................................................................................................................13
3.4.1. Définition ........................................................................................................................................................13
3.4.2. Exemple (voir introduction) ............................................................................................................................13
3.5. LES PROCEDURES (DELPHI : PROCEDURE).................................................................................................................15
3.5.1. Définition ........................................................................................................................................................15
3.5.2. Différence de notation.....................................................................................................................................15
3.5.3. Exemple...........................................................................................................................................................16
3.6. EXERCICES ..............................................................................................................................................................17
3.6.1. Exercice C3E1.................................................................................................................................................17
Version du : 30/12/01 20:47 Page 46

3.6.2. Exercice C3E2.................................................................................................................................................17

3.6.3. Exercice C3E3.................................................................................................................................................17
3.6.4. Exercice C3E4.................................................................................................................................................17
3.6.5. Exercice C3E5.................................................................................................................................................17
3.6.6. Exercice C3E6.................................................................................................................................................18
3.6.7. Exercice C3E7.................................................................................................................................................18
3.6.8. Exercice C3E8.................................................................................................................................................18
3.6.9. Exercice C3E9.................................................................................................................................................18
3.6.10. Exercice C3E10.............................................................................................................................................18
CHAPITRE 4 : PROJET DE SYNTHESE...................................................................................................................19
4.1. INTRODUCTION .......................................................................................................................................................19
4.2. FORMULATION DU PROBLEME .................................................................................................................................19
4.3. ÉVALUATION DU PROJET .........................................................................................................................................19
4.4. CONTRAINTES .........................................................................................................................................................20
4.5. CONSIGNES .............................................................................................................................................................20
CHAPITRE 5 : LES LISTES ET LES COMPOSANTS Y RELATIFS ....................................................................21
5.1. LES LISTES DYNAMIQUES A ACCES DIRECT ..............................................................................................................21
5.1.1. Introduction.....................................................................................................................................................21
5.1.2. Caractéristiques ..............................................................................................................................................21
5.2. LE COMPOSANT "LISTBOX" ....................................................................................................................................21
5.2.1. L'objet TItems..................................................................................................................................................22
5.2.2. Exemples de manipulations de listes ...............................................................................................................22
5.3. EXERCICES ..............................................................................................................................................................23
5.3.1. Exercice C5E1.................................................................................................................................................23
5.3.2. Exercice C5E2.................................................................................................................................................23
5.3.3. Exercice C5E3.................................................................................................................................................24
5.3.4. Exercice C5E4.................................................................................................................................................25
5.3.5. Exercice C5E5.................................................................................................................................................26
5.3.6. Exercice C5E6.................................................................................................................................................26
5.3.7. Exercice C5E7.................................................................................................................................................26
5.3.8. Exercice C5E8.................................................................................................................................................26
5.3.9. Exercice C5E9.................................................................................................................................................26
5.3.10. Exercice C5E10.............................................................................................................................................26
5.3.11. Exercice C5E11.............................................................................................................................................26
5.4. LE COMPOSANT "COMBOBOX" (FRANÇAIS : BOITE A OPTIONS)...............................................................................27
5.4.1. Style d'une "ComboBox" .................................................................................................................................27
5.4.2. Exercice C5E10...............................................................................................................................................27
5.4.3. Exercice C5E11...............................................................................................................................................27
5.4.4. Exercice C5E12...............................................................................................................................................28
CHAPITRE 6 : LES OPERATIONS SUR LES CHAINES DE CARACTERES .....................................................29
6.1. INTRODUCTION .......................................................................................................................................................29
6.2. OPERATIONS AVEC LES CHAINES DE CARACTERES ..................................................................................................29
6.2.1. Concaténation de chaînes de caractères.........................................................................................................29
6.2.2. Longueur d'une chaîne de caractères..............................................................................................................29
6.3. EXTRACTION D'UNE SOUS-CHAINE D'UNE CHAINE DE CARACTERES.........................................................................30
6.4. EXERCICES ..............................................................................................................................................................30
6.4.1. Exercice C6E1.................................................................................................................................................30
6.4.2. Exercice C6E2................................................................................................................................................30
6.4.3. Exercice C6E3.................................................................................................................................................30
6.4.4. Exercice C6E4.................................................................................................................................................31
6.4.5. Exercice C6E5.................................................................................................................................................31
6.4.6. Exercice C6E6.................................................................................................................................................31
6.4.7. Exercice C6E7.................................................................................................................................................31
6.4.8. Exercice C6E8.................................................................................................................................................32
6.4.9. Exercice C6E9.................................................................................................................................................32
6.4.10. Exercice C6E10.............................................................................................................................................32
6.4.11. Exercice C6E11.............................................................................................................................................33
6.4.12. Exercice C6E12.............................................................................................................................................33
6.4.13. Exercice C6E13.............................................................................................................................................33
Version du : 30/12/01 20:47 Page 47

6.4.14. Exercice C6E13 # ..................................................................................................................................33
6.4.15. Exercice C6E14 # ..................................................................................................................................33
6.4.16. Exercice C6E15 # ..................................................................................................................................33
6.4.17. Exercice C6E16 # ..................................................................................................................................33
6.4.18. Exercice C6E17 # ..................................................................................................................................33
CHAPITRE 7 : LES MENUS ET LES COMPOSANTS RELATIFS........................................................................34

7.1. LE MENU PRINCIPAL ................................................................................................................................................34
7.1.1. Création d'un menu .........................................................................................................................................34
7.1.2. L'objet TMenuItem ..........................................................................................................................................34
7.2. LES DIALOGUES ......................................................................................................................................................35
7.2.1. Le dialogue de sauvegarde..............................................................................................................................35
7.2.2. Le dialogue d'ouverture ..................................................................................................................................35
CHAPITRE 8 : PROJET DE SYNTHESE...................................................................................................................36
8.1. INTRODUCTION .......................................................................................................................................................36
8.2. FORMULATION DU PROBLEME .................................................................................................................................36
8.3. ÉVALUATION DU PROJET .........................................................................................................................................36
8.4. CONTRAINTES .........................................................................................................................................................37
8.5. CONSIGNES .............................................................................................................................................................37
CHAPITRE 9 : LES COMPOSANTS D’ANIMATION .............................................................................................38
9.1. LE COMPOSANT "TIMER" ........................................................................................................................................38
9.1.1. Exercice C9E1 : "Chrono"..............................................................................................................................38
9.1.2. Exercice C9E2 : "Animation" .........................................................................................................................38
9.2. LE COMPOSANT "IMAGE" ........................................................................................................................................39
9.2.1. Exercice C9E3.................................................................................................................................................39
9.2.2. Exercice C9E4.................................................................................................................................................39
9.3. UTILISATION DES FONCTIONS POUR FAIRE DES TESTS .............................................................................................41
9.3.1. Exemple...........................................................................................................................................................41
9.3.2. Exercice C7E10...............................................................................................................................................42
9.3.3. Exercice C7E11...............................................................................................................................................43
9.3.4. Exercice C7E12...............................................................................................................................................43
9.3.5. Exercice C7E13...............................................................................................................................................44
9.3.6. Exercice C7E14...............................................................................................................................................45
CHAPITRE 10 : SOLUTIONS MODELES ...................................................................................................................1
10.1. SOLUTIONS DU CHAPITRE 2 .....................................................................................................................................1
10.1.1. Exercice C2E1 (solution modèle)....................................................................................................................1
10.2. LE COMPOSANT "SPINEDIT"..................................................................................................................................10
Version du : 30/12/01 20:47 Page 48

Chapitre 10 : Solutions modèles
10.1. Solutions du chapitre 2
10.1.1. Exercice C2E1 (structure séquentielle)

valeurs initiales
pnlAffiche des propriétés
Color ! clBlue
Caption ! "Hello World"
MouseDown
MouseUp
pnlAfficheMouseDown pnlAfficheMouseUp
pnlAffiche.Color ! clRed pnlAffiche.Color ! clBlue
btnBleu btnRouge pnlAffiche

Caption ! "Bleu" Caption ! "Rouge" Caption ! "Hello World"
btnBleuClick btnRougeClick
btnBleuClick btnRougeClick
pnlAffiche.Color ! clBlue pnlAffiche.Color ! clRed
btnOK edtSaisie pnlAffiche

Caption ! "OK" Text ! "" Caption ! ""
btnOKClick
btnOKClick
pnlAffiche.Caption ! "Bonjour " + edtSaisie.Text
Version du : 30/12/01 20:47 Page 1

btnON btnOFF
Caption ! "ON" Caption ! "OFF"
Enabled ! true Enabled ! false
btnONClick btnOFFClick
btnONClick btnOFFClick
btnOFF.Enabled ! true btnON.Enabled ! true

btnON.Enabled ! false btnOFF.Enabled ! false
Version du : 30/12/01 20:47 Page 2

10.1.5. Exercice C2E5 (structure alternative)
edtValeur1 edtValeur2 pnlSomme

Text ! "0" Text ! "0" Caption ! ""
btnCalculer
Caption ! "Calculer"
btnCalculerClick
btnCalculerClick
pnlSomme.Caption ! inttostr(strtoint(edtValeur1.Text) +
strtoint(edtValeur2.Text))
edtValeur btnCalculer pnlAffiche

Text ! "0" Caption ! "Calculer" Caption ! ""
btnCalculerClick
btnCalculerClick
X ! strtoint(edtValeur.Text)
X < 0
oui non
X ! - X
pnlAffiche.Caption ! inttostr(X)
pnlEntete pnlA pnlB

Caption ! "Résol…" Caption ! "a =" Caption ! "b ="
pnlC pnlResultat btnCalculer

Caption ! "c =" Caption ! "" Caption ! "Calculer"
btnCalculerClick
edtA edtB edtC

Text ! "0" Text ! "0" Text ! "0"
MaxLength ! 5 MaxLength ! 5 MaxLength ! 5
Version du : 30/12/01 20:47 Page 3

btnCalculerClick
A ! strtoint(edtA.Text)
B ! strtoint(edtB.Text)
C ! strtoint(edtC.Text)
DELTA ! B2-4*A*C
DELTA < 0
oui non
S ! "pas de DELTA = 0
solution" oui non
S!floattostr(-B/(2*A)) − B - DELTA
X1 ←
2A
− B + DELTA
X2 ←
2A
S!floattostr(X1)+
floattostr(X2)
pnlResultat.Caption ! S
Remarque :
Les formules peuvent s'écrire de façon naturelle au structogramme. Ce n'est qu'en Delphi, qu'elles
doivent être traduites en forme machine.
Notation au structogramme Notation en Delphi

− B + DELTA
X2 ← X2 ! (-B*sqrt(DELTA))/2*A
2A
Déclaration des variables (en Delphi) :

A, B, C, DELTA : integer
X1, X2 : real
S : string;
Version du : 30/12/01 20:47 Page 4

10.1.8. Exercice C2E8 (structure répétitive)
pnl1L1 pnlL2 pnlS

Caption ! "Limite 1" Caption ! "Limite 2" Caption ! ""
edtL1 edtL2 btnCalculer

Text ! "" Text ! "" Caption ! "Somme"
btnCalculerClick
btnCalculerClick
L1 ! strtoint(edtL1.Text)
L2 ! strtoint(edtL2.Text)
L1 > L2
oui
non
X ! L1
L1 ! L2
L2 ! X
SOMME ! 0
pour X ! L1
SOMME ! SOMME + X
à L2
pnlS.Caption ! inttostr(SOMME)
pnlEntete pnlX pnlY

Caption ! "Calculer…" Caption ! "x = " Caption ! "y = "
pnlAffiche edtX edtY

Caption ! "" Text ! "0" Text ! "1"
btnCalculer
Caption ! "Calculer"
btnCalculerClick
Version du : 30/12/01 20:47 Page 5

btnCalculerClick
X ! strtoint(edtX.Text)
Y ! strtoint(edtY.Text)
Y = 0
oui
non
P ! 1 P ! X
pour I ! 1
P ! P * X
à Y-1
pnlAffiche.Caption ! "x ^ y = "

+ inttostr(P)
edtNum edtDen lblRes

Text ! "" Text ! "" Text ! ""
btnSimplifier
Caption ! "Simplifier"
btnSimplifierClick
btnSimplifierClick
NUM ! strtoint(edtNum.Text)
DEN ! strtoint(edtDen.Text)
I ! 2
tant que (DEN ≥ I) et (NUM ≥ I)

(DEN mod I=0) et (NUM mod I=0)
oui non
NUM ! NUM div I I ! I + 1

DEN ! DEN div I
DEN = 1
oui non
S ! S ! inttostr(NUM) + "/" +
inttostr(NUM) inttostr(DEN)
lblRes.caption ! S
Version du : 30/12/01 20:47 Page 6

10.2. Solutions du chapitre 3
10.2.1. Exercice C3E1 (fonctions)
PUIS(X,Y)
RES ! X
pour I ! 2 à Y
RES ! RES * X
PUIS ! RES
L'instruction TRUNC retourne la valeur entière d'un nombre réel, par exemple : TRUNC(12.34)
retourne 12.
Explication de l'algorithme avec ROUND(12.345,2) : x = 12,345 et n = 2

Il est demandé d'arrondir le nombre 12,345 à 2 positions
décimales. x ⋅ 10 n → 1234,5
( )
trunc x ⋅ 10 n → 1234
( )
trunc x ⋅ 10 n
→ 12,34
10 n
ROUND(X,N)
N = 0
vrai faux
Y ! trunc(X) Y ! trunc(X*PUIS(10,N)/PUIS(10,N))
ROUND ! Y
Remarque :
En Delphi, le symbole pour les positions décimales peut être la virgule ou le point, selon la
configuration de Windows. Vérifier dans le "Control Panel, Regional Setting, Number".
Version du : 30/12/01 20:47 Page 7

π
90° rad
2
0°
0 rad
180° π rad
270° 3
π rad
2
DEG2RAD(X) RAD2DEG(X)
π ⋅ X 180 ⋅ X
DEG2RAD ! RAD2DEG !
180 π
Remarque : Delphi dispose d'une constante prédéfinie "pi".
Remarque :
En Delphi (comme en Pascal), tout angle est représenté en radians. Donc, les fonctions prédéfinies
sin() et cos() opèrent avec des radians. Comme l'utilisateur entre l'angle en degrés, il est
nécessaire de faire la conversion.
TANGENTE(X)
TANGENTE ! sin(X) / cos(X)
btnTangenteClick
X ! speAngle.Value
ANGLE ! DEG2RAD(X)
SINUS ! sin(ANGLE)
COSINUS ! cos(ANGLE)
lblSin.caption ! floattostr(ROUND(SINUS,4))
lblCos.caption ! floattostr(ROUND(COSINUS,4))
ANGLE = 0
vrai faux
lblTan.caption ! "indéfini" TAN ! ROUND(TANGENTE(ANGLE),4)

lblTan.caption ! floattostr(TAN)
Version du : 30/12/01 20:47 Page 8

Version du : 30/12/01 20:47 Page 9

10.3. Le composant "SpinEdit"
Description : Le composant TSpinEdit est dérivé de TEdit,

mais il est spécialement conçu pour faire varier
un nombre entier entre deux valeurs limites.
Propriétés : Value la valeur affichée dans le champ d'édition

MinValue les valeurs limites entre lesquelles Value peut varier
MaxValue
Increment valeur par laquelle Value est incrémentée/décrémentée
Événement : OnChange événement activé lors de la modification de Value
Version du : 30/12/01 20:47 Page 10

Delphi5 Simple

Transféré par

Droits d'auteur :

Formats disponibles

Delphi5 Simple

Transféré par

Informations du document

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

Delphi5 Simple

Transféré par

Droits d'auteur :

Formats disponibles

12e Technique Générale

Année académique : 2001/2002

Titulaire : Serge Linckels

Chapitre 1 : L'approche objet

Chaque individu décrit un même objet

On dit que chaque personne a une

1.2. Exemple : Analyse de l'objet _________________________

Propriétés : ensemble des caractéristiques qui décrivent un objet

1.2.2. Actions possibles

Méthodes : ensemble des fonctions d'un objet

Version du : 30/12/01 Page 2

1.2.3. Représentation graphique

Exemples : Événement Méthode invoquée

1.3. Cycle de développement

1.3.1. Analyse orientée objet

• Création des structogrammes pour les méthodes complexes ;

1.3.3. Programmation orientée objet

• Création de l'interface utilisateur ; sur ordinateur

Version du : 30/12/01 Page 3

Chapitre 2 : L'environnement Delphi

• Delphi est un produit de l'entreprise Inprise (avant : Borland).

2.2. Vu sur les composants de base de Delphi

ListBox ComboBox Panel

EditBox Button CheckBox RadioButton

2.2.1. Le composant "Panel"

Description : Il s'agit d'une simple zone qui peut contenir un

Propriétés : Alignement alignement du texte (centré, gauche, droite)

2.2.2. Le composant "Button"

Description : Il s'agit d'un bouton, contenant un texte et idéal

Propriétés : Alignement alignement du texte (centré, gauche, droite)

Version du : 30/12/01 Page 4

2.2.3. Le composant "EditBox"

Description : Il s'agit d'une zone où l'utilisateur peut entrer un

Propriétés : CharCase minuscules, majuscules, normal

2.2.4. Le composant "ListBox"

Description : Il s'agit d'un tableau qui peut contenir plusieurs

Propriétés : Color couleur de fond

2.2.5. Le composant "ComboBox"

Description : Il s'agit d'une boîte à options. La zone d'édition

Propriétés : Color couleur de fond

2.2.6. Autres composants

2.3. Conventions de dénomination

• Pour les propriétés on utilise le nom proposé par Delphi.

• Pour les méthodes on utilise comme nom : nom_objet + nom_méthode

btnCalculer est le nom de l'objet

• Le nom d'un objet se compose comme suit :

Exemple : lblResultat, btnCalculerDelta, etc.

Version du : 30/12/01 Page 5

Liste des préfixes :

Barre d'outils Préfixe Composant Icône

2.4. L'inspecteur d'objets

Soit le programme suivant :

Version du : 30/12/01 Page 6

2.4.1. La manipulation des propriétés

L'inspecteur des objets (Object Inspecteur) affiche toutes les

• Les propriétés de l'objet sélectionné peuvent être modifiées

• Si l'objet sélectionné est changé sur la forme, par exemple on

La couleur de l'objet "Panel1"

2.4.2. La manipulation des méthodes

Si un événement surgi à l'objet, par exemple que l'utilisateur