Définition Delphi :1

Delphi est à la fois un langage de programmation orienté objet et un environnement de

développement intégré(EDI) pour ce langage.
L'EDI Delphi est un EDI propriétaire fonctionnant sous Windows créé en 1995 par Borland. À
l'époque, créer des programmes graphiques sous Windows se faisait en grande majorité en utilisant
soit la chaîne de compilation Visual C++, soit le RAD « Rapide Application
Développement » Visual Basic. Le premier outil étant excessivement complexe et le second assez
peu structuré, Delphi apparut alors comme une alternative viable pour beaucoup de développeurs
qui souhaitaient créer des programmes pour Windows.
En 2001, Borland édita une version Linux de Delphi appelée Kylix, qui ne connut pas le succès
attendu par l'éditeur.

Depuis 2011, Embarcadero a introduit le Framework Firemonkey en complément de la VCL

(Visual Component Library) qui a permis progressivement de compiler les mêmes programmes
sur d'autres plateformes.

Actuellement Delphi permet de générer des exécutables Windows, MacOs, iOS, Android et Linux
depuis des programmes écrits en Object Pascal sous Windows.

Le Pascal Objet
Delphi implémente une version orientée objet du langage Pascal : le Pascal Objet, renommé
Langage de programmation Delphi au fil des modifications apportées par Borland. Le Pascal
Objet de Delphi possède plusieurs avantages qui améliorent la productivité du développeur par
rapport au C++ : typage fort, contrôle strict du compilateur pour éviter les erreurs de mémoire, de
débordement, gestion intégrée des chaînes de caractères et des tableaux dynamiques, etc. La
compilation ne se fait qu'en une seule passe et il n'y a pas de séparation entre l'implémentation et
l'interface comme en C ou en C++ : la génération d'un projet Delphi est donc très rapide, ce qui a
accru à sa sortie la popularité de l'outil vite réputé pour ses temps de compilation record.
Bien que le Pascal Objet introduise une multitude de concepts intéressants et novateurs (de
nombreux ont été repris avec C#), il souffre de faiblesses connues. Par exemple, il ne permet pas
certaines fonctionnalités de POO « Programmation Orienté Objet » telles que l'héritage multiple
de classes. Certaines fonctionnalités comme la surcharge d'opérateurs et la généricité n'ont été
introduits que tard (respectivement avec Delphi 2005 et Delphi 2009). De plus, sa parenté avec le
Pascal rebute de nombreux programmeurs plus habitués à des styles de programmation proches
de Java ou C. Enfin, il n'est ni standardisé ni géré par un comité indépendant : propriété
d'Embarcadero, l'éditeur est le seul à pouvoir décider de l'avenir et de l'ajout de nouvelles
fonctionnalités au langage.

1
[Link]
L'interface de développement :2
L'environnement de développement s'appuie sur un éditeur d'interface graphique associé à un
éditeur de code source. Il doit son succès à sa facilité d'utilisation pour développer des applications
graphiques et/ou liées aux bases de données. On l'a souvent comparé à Visual
Basic de Microsoft pour cette facilité de développement. On peut même dire que par un amusant
mouvement de balancier et de personne, le VB influença Delphi qui à son tour influença par la
suite le VB (Anders Hejlsberg lors de son passage chez Microsoft).

L'environnement de développement auto-génère du code pour faciliter le travail du programmeur. Il

maintient une correspondance automatique entre la vue de conception (la fenêtre que le
programmeur bâtit en déposant des composants graphiques) et l'éditeur de code (la vue affichant le
code source qui créera ces composants à l'exécution). Les données spécifiques aux composants sont
stockées dans des fichiers d'extension .DFM alors que le code source en Pascal Objet est
sauvegardé dans des fichiers d'extension .PAS. Alors que d'autres langages (comme C# avec
Winforms) génèrent les instructions nécessaires à la création des composants de l'interface et
l'injectent dans une section du code source du programme, Delphi sépare les données statiques de
description des objets d'interface, à la manière de XAML, et se base sur des routines de la VCL
pour relire et présenter l'interface lors de l'exécution.

L'interface de développement permet l'ajout de composants tiers (graphiques ou non) via un

système de composants. La modularité est obtenue à la conception mais peut aussi être exploitée à
l'exécution via un système de chargement dynamique de paquets d'exécution, Borland ayant étendu
le concept de bibliothèques partagées et le format Windows DLL en introduisant un modèle
propriétaire permettant d'enregistrer dynamiquement et d'exporter des classes entre modules. Le
même système sera repris par Microsoft sous Visual Basic avec le format VBX, puis à l'échelle du
système avec les composants COM et ActiveX.

2
[Link]
Installation DELPHI 10 :

L’interface d’installation de DELPHI 10

Accepter les termes du Contrat cliquer sur « Suivant »

Cliquez « Suivant »
Sélectionner Full installation
puis cliquez « Suivant »

Cliquez « Suivant »
• Cochez Add Bin Path
environnement variable
• Cochez Add Bin Path
environnement variable
• Puis cliquez Suivant

Dans la fenêtre du résumé

cliquez « Suivant »
Début de l’installation

Fin de l’installation
L’EDI de Delphi :
1. L’interface de Delphi :3
La figure ci-dessous représente l’interface typique de Delphi. On peut créer un application
Windows VCL ou une application multi device FMX

3
J. Darmont Programmation sous Delphi / université de Lyon 2 année 1999-2000
La fenêtre d’un projet VCL/FMX et composé de :

La barre de menus :
Les menus
• Menu Fichier : création, ouverture, enregistrement…
• Menu Édition : annulation, copier, coller…
• Menu Chercher : chercher, remplacer…
• Menu Voir : gestionnaire de projets, inspecteur d’objets, déboguage…
• Menu Projet : compilation de code source, options de compilation…
• Menu Exécuter : exécution de programmes, déboguage…
• Menu Composant : création de nouveau composant, configuration de la palette de composants…
• Menu Bases de donnée
• Menu Outils : options, utilitaires…
• Menu Aide : indispensable ! à utiliser sans modération…
La barre d’icônes :
La barre d'icônes contient les commandes les plus utilisées : elle est divisée en trois groupes
d'icônes.
• Les commandes de gestion de projets (menu fichier) : ouvrir ou fermer un projet ou un
fichier et ajouter ou enlever un fichier d'un projet
• Les commandes de conception (menu voir) : afficher la liste des unités et des fiches, créer
une nouvelle fiche vierge et passer de la fiche à son unité
• Les commandes d'exécution (menu Exécuter) : exécuter ou suspendre l'exécution ou
exécuter pas à pas
L'aspect de la barre d'icône peut être modifié en utilisant le menu déroulant de la barre et en
choisissant l'option propriétés.

La palette des composants :

Une fiche constitue l’interface (ou une partie de l’interface) d’une application. Pour concevoir
une fiche, il suffit d’y insérer des contrôles (ressources Windows prêtes à l’emploi : boutons de
commande, listes, menus…) listés dans la palette des composants. Un clic sur le contrôle, puis
un autre sur la fiche cible suffisent (un double clic insère le composant au milieu de la fiche
active). La palette des composants réunit plusieurs volets.
Les principaux sont listés ci-dessous :
Composants standards :

Contrôle Nom Pascal Description

Menu principal MainMenu Barre de menus
Menu surgissant PopupMenu Menu contextuel
Étiquette Label Zone d’affichage de texte non modifiable
Boîte d’édition permettant la saisie ou la
Édition Edit
modification d’une ligne de texte
Boîte d’édition permettant la saisie ou la
Mémo Memo
modification d’un texte de plusieurs lignes
Bouton Button Bouton de commande simple
Case à cocher CheckBox Sélection de choix entre plusieurs
Bouton radio RadioButton Sélection d’un choix entre plusieurs
 Boîte de liste simple ListBox Liste [déroulante] d’éléments
Liste déroulante d’éléments avec possibilité
Boîte de liste combinée ComboBox
d’édition sans une boîte d’édition
Barre de défilement ScrollBar Ascenseur vertical ou horizontal
Boîte de groupe GroupBox Cadre conteneur de contrôles
Groupe de boutons radio RadioGroup Cadre conteneur de boutons radio
Volet Panel Volet conteneur de contrôles

Composants supplémentaires :
 Contrôle Nom Pascal Description
Bouton bitmap BitBtn Bouton de commande avec image bitmap
Turbo bouton SpeedButton Icône dans une barre d’outils
Boîte d’édition permettant des saisies
Masque de saisie MaskEdit
formatées
Grille de chaînes StringGrid Tableau d’affichage de chaînes
Grille d’affichage DrawGrid Tableau d’affichage de données
Zone d’affichage d’une image bitmap, d’une
Image Image
icône ou d’un métafichier Windows
Forme Shape Forme géométrique (ellipse ou rectangle)
Biseau Bevel Ligne ou rectangle 3D
Conteneur de composant possédant des
Boîte de défilement ScrollBox
barres de défilement
Boîte de liste à cocher CheckListBox Liste [déroulante] d’éléments à cocher
Séparateur Splitter Séparateur mobile
Texte statique StaticText Étiquette contenant un descripteur de fenêtre
Graphique Chart Graphique type Excel

Composants boîtes de dialogue :

Boîte de dialogue Nom Pascal Description
Ouvrir OpenDialog Ouverture d’un fichier
Enregistrer sous SaveDialog Sauvegarde d’un fichier
Ouvrir image OpenPicture Ouverture d’un fichier image
Enregistrer image SavePicture Sauvegarde d’un fichier image
Fontes FontDialog Sélection d’une police de caractère
Couleurs ColorDialog Sélection d’une couleur dans la palette
Imprimer PrintDialog Impression d’un document
Configuration
PrinterSetupDialog Paramétrage de l’imprimante
impression
Recherche FindDialog Recherche d’une donnée
Recherche et remplacement d’une
Remplacer ReplaceDialog
donnée
L’éditeur de code :
Les fichiers de code source composant un projet sont rassemblés dans l’éditeur de code. À chaque
fiche est associée une unité identifiée par un onglet situé en haut de la fenêtre de l’éditeur.
L’éditeur permet de modifier le code Pascal de ces unités.
L’inspecteur d’objets :
Cet outil est dédié à la gestion des composants. La fenêtre
de l’inspecteur contient deux volets :
• la liste des propriétés (attributs) du composant courant, •
la liste des événements associés au composant courant.
Propriétés :
Les noms des propriétés sont placés dans la colonne
de gauche (dans l’ordre alphabétique) et les valeurs
sur la ligne correspondante à droite.
Les propriétés dont le nom est précédé d’un + ont
plusieurs niveaux imbriqués (ex. Font).
Lorsqu’une propriété de ce type est « déroulée »,
le signe – apparaît à la place du signe +.
Pour donner une valeur à une propriété, le plus
simple est de remplacer sa valeur par défaut par
une nouvelle valeur dans la boîte d’édition pré-
vue à cet effet.
La propriété Name est particulièrement importante
car elle permet d’accéder au composant depuis les
programmes. Par défaut, Delphi lui confère une
valeur peu explicite (ex. Form1, Button1…). Il est
préférable d’utiliser des noms plus « parlants ».
Les propriétés visibles dans l’inspecteur sont
modifiables lors de la phase de conception.
D’autres propriétés sont uniquement accessibles
lors de l’exécution, grâce à du code source.
Événements :
La colonne de gauche contient l’ensemble des
événements associés à un composant donné.
Ex. OnClick, commun à un grand nombre de
composants, qui est activé lorsque l’utilisateur
clique sur le composant.
La colonne de droite consiste en une série de
boîtes de listes combinées permettant
d’associer un gestionnaire d’événements à
l’événement correspondant (i.e., un ensemble
d’instructions Pascal exécutées lorsque
l’événement survient).
Sur un double clic sur une de ces boîtes,
l’éditeur de code s’ouvre et le curseur se
positionne à l’intérieur du gestionnaire
d’événements (une procédure)
4
Les événements sont des actions déclenchées par l'utilisateur, par l'environnement où s'exécute
l'application ou par l'application elle-même (en conséquence au résultat de l'exécution d'une
instruction de l'application) et auquel le programme devrait répondre.

Propriétés :
Comme un champ, une propriété définit un attribut d'un objet. Mais alors qu'un champ n'est rien de
plus qu'un emplacement de stockage dont le contenu peut être consulté et modifié, une propriété
associe des actions spécifiques à la lecture et la modification de ses données.
Les propriétés proposent un moyen de contrôler l'accès aux attributs d'un objet et permettent le
calcul des attributs.
Ils existent deux modes pour modifier la valeur d’une propriété :
- mode création :

Dans l’inspecteur d’objets choisissez la propriété dont vous voulez modifier la valeur puis changer
la valeur en face.
- mode exécution :
Pour modifier une propriété en mode exécution il faut savoir le nom de l’objet, le nom de la
propriété ainsi que ces valeurs.

4
[Link]
Exemple :

[Link] :=false ; / cacher l’objet Rectangle1

[Link] :=true ; / afficher l’objet Rectangle1

[Link] :=[Link] ; / donner la largeur de l’écran a la fenêtre Form 1

Remarque :

La modification d’une propriété en mode exécution ne sera pris en charge qu’à l’exécution du
projet

➢ La propriété Name est particulièrement importante car elle permet d’accéder au composant
depuis les programmes. Par défaut, Delphi lui confère une valeur peu explicite (ex. Form1,
Button1…).

• Il est préférable d’utiliser des noms plus « parlants ».

• Les propriétés visibles dans l’inspecteur sont modifiables lors de la phase de conception .
 ➢ La propriété Color de la fiche

• Repère la propriété Color et clique dans la zone indiquant la

couleur

Une liste déroulante des différentes couleurs disponibles apparaît

• Sélectionne la couleur bleue référencée par la notation clBlue

(signifiant, bien sûr, couleur bleue)

La couleur de la fiche se modifie instantanément.

➢ La propriété Width contrôle la largeur d’un objet comme la form, button,panel…etc

➢ La propriété Top indique la hauteur d’un objet par rapport à l’objet parent

Exemple : form par rapport à l’écran, button par rapport à la form , un button par rapport au
panel

➢ La propriété Left indique la position de la limite gauche de l’objet

➢ La propriété Hint sert pour afficher un petit aide sur l’objet survolé
➢ La propriété BorderStyle indique contrôle le style des bordures de l’objet qu’ils soient
modifiables ou non, avoir des bordures ou non …etc. Chaque objet a un style de bordures
➢ La propriété Visible est une des propriétés importantes elle contrôle la visibilité de l’objet
Si la propriété prend la valeur TRUE l’objet sera visible sinon la valeur FALSE pour qu’il
ne soit pas visible
➢ La propriété Enabled indique si l’objet est actif ou non si la valeur de la propriété est
TRUE donc l’objet est actif et on peut le manipulé mais si la valeur est FALSE donc l’objet
sera inactif.

Tableau des évènements les plus utilisés :

Evenements Explications

OnActivate Quand l’élément est activé.

OnDesactivate Quand l’élément va être désactivé.

OnCreate Quand l’élément est créé.

OnClose A la fermeture de l’élément.

OnDestroy A la destruction de l’élément.

OnHide Au moment où l’élément deviendra caché.

OnShow A l’affichage de l’élément.

OnResize Au redimensionnement de l’élément.

OnKeyPress A la frappe d’une touche de clavier.

OnKeyDown Au moment où la touche du clavier est pressée.

OnKeyUp Au moment où la touche du clavier est relâchée.

OnEnter Au moment ou le curseur focalisera sur l’élément.

OnChange A chaque fois que le contenu change.

OnClick Au moment où on click sur le bouton gauche de la souris.

OnDblClick Au moment où on double click sur le bouton gauche de la souris.

OnMouseMove Au moment où le pointeur de la souris touche l’élément.

OnMouseLeave Au moment où le pointeur de la souris quitte l’élément.

OnMouseDown Au moment où la touche de la souris est enfoncée.

OnMouseUp Au moment où la touche de la souris est relâchée.

Fichiers d’un projet DELPHI 10 :

Concrètement, un projet est un fichier binaire d’extension « .dpr"

contenant des liens vers tous les éléments du projet (fiches, unités, etc.),
eux-mêmes stockés dans des fichiers séparés.

Code objet compilé .dcu

Programme exécutable .exe

Fichier Extension Contenu

Projet .dpr Code d’initialisation du programme
Code source des procédures, fonctions,
fiches, ou composants
Code source .pas (explicitement implémenté par l’utilisateur
ou automatiquement généré par Delphi)

Caractéristiques et propriétés des

Fiches .dfm composants sous
forme binaire
Fichier binaire contenant les ressources
Windows
Ressources .res
utilisées par l’application (ex. l’icône du
programme)

Compilation d’un projet :

Lors de la compilation, chaque fiche (fichier «. DFM ») avec son unité (fichier «. PAS ») seront
transformées en un seul fichier (. DCU).

Tous les fichiers «. DCU » seront transformés en un seul fichier exécutable .EXE qui représente
l’application Delphi générée. Le fichier .EXE porte le même nom que le fichier projet «. DPR »

L’audit de code :
Pour accéder à l’audit il suffit de cliquer sur le clavier « CTRL + ESPACE »
 Ajouter de nouvelles fiches :
Pour ajouter des fiches au projet il existe deu x méthodes
Les boutons Button, bitbtn et speed button :
TButton est le bouton Windows très basique qui n'a pas de moyen facile de définir un glyphe.
TBitBtn possède toutes les fonctionnalités de TButton et ajoute la possibilité de définir un
glyphe.
Contrairement aux contrôles TButton et TBitBtn, TSpeedButton ne capture pas le "focus de
tabulation", ce qui signifie que lorsque vous cliquez sur un bouton de vitesse, votre focus ne bouge
pas - rendant TSpeedButton idéal pour implémenter des raccourcis / boutons.
C'est une liste non exhaustive de près de 40 procédures et fonctions très utiles en Delphi.
LES ENTIERS

➢ IntToStr
function IntToStr(Value:integer):string;
Permet d'afficher un nombre entier dans une chaîne de caractères.
Exemple :
uses SysUtils, Dialogs;
begin
ShowMessage(IntToStr(50)); end.

➢ StrToInt
function StrToInt(Value:string):integer;
Permet de convertir une chaîne de caractères en son nombre entier écrit dedans.
Exemple :
uses SysUtils, Dialogs;
begin
if StrToInt('50')=50 then
ShowMessage('C''est vrai'); end.

➢ Round
function Round(Value:real):integer;
Permet d'arrondir un nombre flottant de manière à le convertir en nombre entier par l'arrondi le plus
proche. Exemple : uses Dialogs;
begin if Round(3.78)=4
then ShowMessage('C''est
vrai'); end.

➢ Trunc
function Trunc(Value:real):integer;
Permet d'arrondir un nombre flottant de manière à le convertir en nombre entier par troncature.
Exemple : uses Dialogs;
begin
if Trunc(3.78)=3 then
ShowMessage('C''est vrai'); end.

➢ Inc
procedure Inc(var Value:integer);
Permet d'incrémenter la valeur d'un entier.
Exemple :

uses Dialogs;
var i : integer;
begin i:=50;
inc(i); if i=51
then
ShowMessage('C''est vrai'); end.
REMARQUE : l'utilisation de INC est strictement équivalente à faire i:=i+1;

➢ Dec
procedure Dec(var Value:integer);
Permet de désincrémenter la valeur d'un entier.

Exemple : uses
Dialogs;
var i : integer;
begin i:=50;
dec(i); if
i=49 then
ShowMessage('C''est vrai'); end.
REMARQUE : l'utilisation de DEC est strictement équivalente à faire i:=i-1;

➢ Random
procedure Random(Value:integer);
Génère un nombre aléatoire compris entre 0 et Value-1.
Exemple : uses Dialogs;
var i : integer;
begin
//Randomize;
i:=Random(50);
if i<50 then
ShowMessage('C''est toujours vrai'); end.

REMARQUE : l'utilisation de Random doit être précédée d'une initialisation unique (au lancement
de votre programme le plus souvent) via la fonction Randomize qui n'a pas de paramétrage

REMARQUE : Pour générer un nombre entre 2 et 10, vous faîtes : i:=Random(10-2+1)+2;

➢ Odd
function Odd(Value:integer):boolean;
Dit si le nombre proposé est impair.
Exemple : uses
Dialogs;
begin
if not Odd(50) then
ShowMessage('Ce nombre est pair'); end.

LES FLOTTANTS
➢ FloatToStr
function FloatToStr(Value:real):string;
Permet d'afficher un nombre à virgule dans une chaîne de caractères.
Exemple : uses
SysUtils, Dialogs;
var s : string; begin
s:=FloatToStr(50.12);
ShowMessage(s); end.

REMARQUE : une notation scientifique peut être à prévoir si le nombre est trop grand

➢ StrToFloat
function StrToFloat(Value:string):real;
Permet de convertir une chaîne de caractères en son nombre flottant écrit dedans.
Exemple : uses SysUtils, Dialogs;
var f : real;
begin
f:=StrToFloat('50,49');
if f=50.49 then
ShowMessage('C''est vrai'); end.

➢ Int
function Int(Value:real):real;
Permet de garder la partie entière d'un nombre flottant.
Exemple : uses
SysUtils, Dialogs;
var f : real;
begin
f:=Int(50.49);
if f=50 then
ShowMessage('C''est vrai'); end.

REMARQUE : le résultat n'est pas de type entier compte tenu de l'étendue énorme des nombres
flottants par rapport aux entiers (même int64 qui ne supporterait pas)
 ➢ Power
function Power(Base,Exponent:real):real;
Permet de calculer une puissance : Base^Exponent.
Exemple : uses Math;
var f : real; begin
f:=Power(2, 1.4);
end.

REMARQUE : Power utilisera diverses fonctions selon que l'exposant est entier, négatif, nul... afin
d'éviter l'usage systématique de LN et EXP.

LES CHAÎNES DE CARACTÈRES

➢ Lenght
function Length(Value:string):integer;
Renvoie la longueur de la chaîne.
Exemple :
uses SysUtils, Dialogs;
begin
ShowMessage(IntToStr(Length('Vaut 6'))); end.

➢ Pos
function Pos(SubChain,Chain:string):integer;
Renvoie la position d'une sous-chaîne dans une chaîne.
Exemple : uses Dialogs;
begin
if Pos('alu','Salut')=2 then
ShowMessage('C''est vrai'); end.

REMARQUE : si la chaîne n'est pas trouvée dans l'autre, le résultat est 0.

➢ Copy
function Copy(Chain:string; Pos,Len:integer):string;
Extrait une sous-chaîne d'une chaîne.
Exemple : uses Dialogs;
begin
 ShowMessage(Copy('Salut les amis !',11,4)); //='amis' end.
➢ UpperCase
function UpperCase(Chain:string):string;
Convertit les lettres de l'alphabet en majuscule dans la chaîne considérée.
Exemple : uses Dialogs;
begin
ShowMessage(UpperCase('Amitié')); //='AMITIé' end.

➢ LowerCase
function LowerCase(Chain:string):string;
Convertit les lettres de l'alphabet en minuscules dans la chaîne considérée.
Exemple : uses Dialogs;
begin
ShowMessage(LowerCase('MAJUSCULES')); //='majuscules'
end.

➢ AnsiUpperCase
function AnsiUpperCase(Chain:string):string;
Convertit en majuscule lettres et accents d'une chaîne donnée.

➢ AnsiLowerCase
function AnsiLowerCase(Chain:string):string;
Convertit en minuscules lettres et accents d'une chaîne donnée.
REMARQUE : dans la plupart des cas, les Ansi* sont exagérées pour un simple test de conditions
LES BOOLÉENS

➢ NOT
NOT
Donne le booléen opposé.
Exemple :

var b : boolean;
begin
b:=false;
b:=not b; if
b=true then
ShowMessage('C''est vrai'); end.

➢ AND
AND
Combine deux booléens de manière à savoir si les deux sont vrais.
Exemple :

var b1, b2 : boolean;

begin b1:=true;
b2:=false; if b1
and b2 then
ShowMessage('Vous ne verrez pas ce message'); end.

➢ OR
OR
Combine deux booléens de manière à savoir si au moins l'un des deux est vrai. Exemple
:

var b1, b2 : boolean;

begin
b1:=true;
b2:=false; if b1
or b2 then
ShowMessage('C''est vrai car b1=true'); end.
 ➢ XOR
XOR
Combine deux booléens de manière à savoir si l'un des deux seulement est vrai.
Exemple var b1, b2
: boolean;
begin b1:=true;
b2:=false; if b1
xor b2 then
ShowMessage('C''est vrai: b1=true');
if b1 xor (not b2) then
ShowMessage('Vous ne verrez pas ce message.'); end.

D'AUTRES FONCTIONS UTILES

function ParamStr(Index:integer):string;
Récupère la ligne de commande et le paramétrage de l'application.
INDEX CONTENU

0 Nom complet de l'application

1 Paramétrage usuel : fichiers assignés avec "Ouvrir avec", configuration des raccourcis
"[Link] -nocheck"

2..infini Paramétrage complémentaire souvent inutilisé. Tout dépend si vous utilisez %2 ou %1

dans les commandes de [Link]

Showmessage :
La procédure showmessage affiche une chaîne de texte dans une boîte de dialogue simple avec
un bouton OK.
Il est utilisé pour informer l'utilisateur de certaines informations - aucune décision n'est requise par
l'utilisateur.
Insérez les caractères de retour chariot et de saut de ligne (# 13 # 10) dans la chaîne pour générer
l'affichage des messages sur plusieurs lignes.
Messagedlg :
La fonction messagedlg est utilisée pour afficher des messages à l'utilisateur. Ces messages
peuvent être informatifs, ou des avertissements ou autres. Il y a une liberté totale sur le choix des
boutons que l'utilisateur peut appuyer pour confirmer la boîte de dialogue.
Par exemple, l'utilisateur peut afficher un message d'erreur et être autorisé à annuler, réessayer ou
annuler le processus erroné.
DialogType peut avoir l'une des valeurs énumérées suivantes:
mtWarning Affiche un symbole d'exclamation mtError
Affiche un 'X' rouge mtInformation Affiche
un 'i' dans une bulle mtConfirmation Affiche un point
d'interrogation mtCustom Affiche seulement le message
La valeur Buttons peut être une ou plusieurs des valeurs énumérées suivantes:
mbYes Affiche un bouton "Oui" mbNo
Affiche un bouton "Non"
MBOK Affiche un bouton "OK"
mbCancel Affiche un bouton "Annuler"
mbAbort Affiche un bouton "Abandonner"
mbRetry Affiche un bouton "Réessayer"
mbIgnore Affiche un bouton "Ignorer"
mbAll Affiche un bouton "Tous" mbNoToAll
Affiche un bouton "Non à tous" mbYesToAll
Affiche un bouton "Oui à tous" mbHelp
Affiche un bouton "Aide"
 Vous spécifiez ces valeurs séparées par des virgules entre crochets, comme dans le second exemple
de code.
Delphi fournit un certain nombre de combinaisons de boutons prédéfinies:
mbYesNoCancel = [mbYes, mbNO, mbCancel]
mbYesAllNoAllCancel = [mbYes, mbYesToAll, mbNo, mbNoToAll, mbCancel]

mbOKCancel = [mbOK, mbCancel] mbAbortRetryCancel =

[mbAbort, mbRetry, mbCancel] mbAbortIgnore = [mbAbort,

mbIgnore]

Maintenant Delphi semble avoir fait une erreur de conception lors de la définition de la valeur
de retour à partir de la boîte de dialogue. Au lieu de spécifier la valeur d'énumération du bouton
enfoncé, il utilise un ensemble complètement différent de noms d’énumération : mrOui = 6
mrNo = 7 mrOK = 1 mrAnnuler = 2 mrAbort = 3 mrRetry = 4 mrIgnore = 5 mrAll = 8
mrNoToAll = 9 mrYesToAll = 10
Les valeurs données sont les valeurs numériques de ces énumérations, données dans l'ordre
numérique que les équivalents mb sont définis. C'est très étrange.
De plus, ces valeurs sont définies dans l'unité Contrôles et non dans l'unité Dialogues.
Notez que le bouton Aide n'a aucune valeur de retour équivalente. C'est parce qu'il ne termine pas
le dialogue.
La valeur HelpContext est utilisée conjointement avec le bouton Aide . Son utilisation est au-delà
de la portée de Delphi Basics.