PROGRAMMATION 1 PASCAL (BORLAND PASCAL)

PROGRAMMATION 1
PASCAL
(BORLAND PASCAL)
Syntaxe commentée de Pascal.
Utilisation de l’environnement de développement.
Spécifications externes des unités développées pour
l’enseignement de programmation :
WinText mode console,
WinTGr simulation de graphiques de type « tortue »
(TurtleGraphics),
WinAppli programmation événementielle mono fenêtre.
A. Lacheny
rév. septembre 2002
SOMMAIRE
SOMMAIRE ...............................................................................................................................................2
I. SYNTAXE DE PASCAL....................................................................................................................1
1. Structure de programme .................................................................................................................. 1
2. Déclarations..................................................................................................................................... 2
3. Instructions ...................................................................................................................................... 3
4. Expressions...................................................................................................................................... 6
5. Types ............................................................................................................................................... 8
6. Constantes ..................................................................................................................................... 10
7. Éléments de base ........................................................................................................................... 11
8. Unités............................................................................................................................................. 11
9. Mots réservés (sous-ensemble)...................................................................................................... 14
10.
Principaux identificateurs prédéfinis......................................................................................... 14
II.
UTILISATION DE BORLAND PASCAL .......................................................................................16
1. Contenu du répertoire Pascal ....................................................................................................... 16
2. Installation de BORLAND Pascal................................................................................................. 17
3. Description des unités Pascal ........................................................................................................ 17
III. UNITÉ « WinText » .........................................................................................................................18
IV. UNITÉ « WinTGr » ..........................................................................................................................21
V.
UNITÉ « WinAppli » ........................................................................................................................26
1. PRÉSENTATION GÉNÉRALE ................................................................................................... 26
2. FONCTIONNALITÉS .................................................................................................................. 28
3. PROCÉDURES GRAPHIQUES................................................................................................... 30
4. PROCÉDURES UTILITAIRES.................................................................................................... 32
5. DIALOGUES « FICHIERS » ....................................................................................................... 34
VI. LISTE DES PROCÉDURES & FONCTIONS PRÉDÉFINIES .......................................................37
I. SYNTAXE DE PASCAL
La syntaxe de Pascal peut être représentée par la description sous forme de graphes orientés de ses
unités syntaxiques. Les groupes syntaxiques (dont la description est faite dans un graphe) sont
représentées par un rectangle
(les précisions
en italique permettant
d'en
justifier
l'utilisation)
ovale
et
les
symboles
terminaux
par
un
cercle
ou
un
.
La syntaxe proposée est un sous-ensemble suffisant pour mettre en œuvre les algorithmes étudiés
dans l’U.V. Programmation 1.
1.
Structure de programme
1.1
Programme
Programme ::=
Un programme débute par le mot-clé program suivi de son nom, d'un point virgule, du contexte
d'utilisation (notions prédéfinies), d'un bloc de description et se termine par un point.
1.2
Environnement d'utilisation
Contexte ::=
Un contexte peut être vide, sinon il débute par le mot-clé uses suivi de la liste des noms des unités
séparés par des virgules (si il y a un seul nom, il n'apparaît pas de virgule) et se termine par un pointvirgule.
Exemple :
uses
WinText, Utile;
1.3
Bloc de description
Bloc ::=
Un bloc est constitué par les déclarations suivies des instructions.
PROGRAMMATION PASCAL : 1. SYNTAXE DE PASCAL.
1
2.
Déclarations
2.1
Déclarations
Déclarations ::=
2.2
Déclaration de constantes
Déclaration de constante(s) ::=
Exemple :
const
Pi = 3.1415926;
Un = 1;
2.3
Déclaration de types
Déclaration de type(s) ::=
Exemple :
type
TEntier = Integer;
TFichier = Text;
2.4
Déclaration de variables
Déclaration de variable(s) ::=
Exemple :
var
E1, Total: TEntier;
Fich: Text;
2.5
Déclaration de procédure ou de fonction
Déclaration de procédure ::=
2.6
En-tête de déclaration de procédure ou de fonction
En-tête de procédure ::=
Type id = Identificateur (de type)
Une déclaration de procédure est constituée par l'identificateur de la procédure suivi des paramètres
formels et du bloc de description. Une déclaration de fonction est, en plus, suivie de l'identificateur du
type du résultat (de la fonction) (un identificateur de type est un identificateur apparaissant dans une
déclaration de type).
En BORLAND Pascal, le type du résultat d’une fonction doit être un type prédéfini (11.1).
2.7
Paramètres formels de procédure ou de fonction
Paramètres ::=
Type id = Identificateur (de type)
La liste des paramètres formels peut être vide.
Exemples : (en-têtes de procédures et de fonctions)
procedure Proc1;
procedure Proc2(var X: T1; Y, Z: T1);
procedure Proc3(var X: T1; Y: T2; var Z: T2);
function Fonc1: T1;
function Fonc2(X, Y :T1): T2;
2.8
Annonce de procédure ou de fonction
Annonce de procédure ::=
La procédure (ou fonction) dont l'en-tête est décrit va être déclarée plus loin dans le programme.
3.
Instructions
3.1
Liste d'instructions
Instructions ::=
Une liste d'instructions est « encadrée » par begin et end, chaque instruction est séparée de la
suivante par un point virgule.
PROGRAMMATION PASCAL : 1. SYNTAXE DE PASCAL.
3
3.2
Instruction
Instruction ::=
Une instruction peut toujours être remplacée par une liste d'instructions (3.1) ou être vide.
3.3
Affectation
Affectation ::=
3.4
Appel de procédure
Appel de procédure ::=
3.5
Structure d'instruction d'alternative
Instruction alternative ::=
Si les éléments de l'alternative portent sur plusieurs instructions, l'unité syntaxique Instruction doit
être associée à l'unité Instructions (3.1) en ajoutant les mots-clés begin et end.
3.6
Structure d'instruction de choix scalaire
Instruction de choix ::=
Une expression scalaire est une expression dont le type associé est scalaire —ensemble des types que
l'on peut injecter dans les entiers par la fonction Ord—.
Choix scalaire ::=
Fin case ::=
La fin de l'instruction (délimitée par else) permet la récupération de tous les autres cas d'évaluation
de l'expression scalaire.
3.7
Structure d'instruction répétitive
Instruction répétitive ::=
3.7.1
« tant que »
Instruction répétitive “tantque” ::=
3.7.2
« répéter »
Instruction répétitive “répéter” ::=
3.7.3
« pour »
Instruction de parcours d'intervalle scalaire ::=
Description d'intervalle ::=
L'instruction for est une extension de l'instruction while dans le cas particulier du parcours exhaustif
d’un intervalle scalaire (parcours ascendant : to ou descendant : downto)
3.8
Sélection
Sélection ::=
L'instruction with permet de « factoriser » (alléger l'écriture) la désignation des constituants d'une
structure d’« enregistrement » (record).
PROGRAMMATION PASCAL : 1. SYNTAXE DE PASCAL.
5
4.
Expressions
La distinction syntaxique entre « Expression », « Expression simple », « Terme », et « Facteur »
permet de formaliser la notion de priorité entre opérateurs.
4.1
Expression
Expression ::=
4.2
Expression simple
Expression simple ::=
4.3
Terme
Terme ::=
4.4
Facteur
Facteur ::=
4.5
Variable
Variable ::=
Exemples :
…
…
…
…
…
V1 …
T1[12, (X*2) div 3 + 1] …
V39.Champ1[I + 1].Champ2 …
Ptr^ …
Vx[V3]^.Champ1[120] …
4.6
Appel de fonction
Appel de fonction ::=
4.7
Descripteur d'ensemble
Ensemble ::=
Exemples :
… [] …
… [0, 2..9] …
… ['A'..'Z', 'a'..'z', '0'..'9', '_'] …
4.8
Descripteur de sous-ensemble
Sous-ensemble ::=
PROGRAMMATION PASCAL : 1. SYNTAXE DE PASCAL.
7
5.
Types
5.1
Définition de type
Type ::=
Un type peut être identifié à un type déjà défini (Integer, Real, Char, Boolean, Text, …), être un
type scalaire construit ou être construit à partir de types déjà définis.
5.2
Constructeur de type scalaire
Type scalaire ::=
Un type scalaire peut être identifié à un type scalaire déjà défini (Integer, Char, Boolean, …), être
construit comme un intervalle (d'un type scalaire) ou une énumération d'identificateurs.
5.3
Constructeur de type intervalle
Type intervalle ::=
Les constantes doivent être du même type scalaire.
Exemples :
TCode = 1 .. 95;
TLettre = 'A' .. 'Z';
5.4
Constructeur de type énuméré
Type énuméré ::=
Un type énuméré est défini comme une liste d'identificateurs ; ces identificateurs sont les constantes
du nouveau type.
Exemples :
TCouleur = (Rouge, Orange, Jaune, Vert, Bleu, Violet);
TLogique = (Faux, Possible, Vrai);
5.5
Constructeur de type tableau
Type tableau ::=
Exemples :
TTab1
TScal
Ttab2
Ttab3
5.6
=
=
=
=
array['A'..'Z'] of T1;
'a'..'k';
array[TScal] of T2;
array[1..20, False..True] of T3;
Constructeur de type enregistrement
Type enregistrement ::=
Exemples :
TEnr1 = record
Champ1, Champ2 :T1;
Champ3: T2
end;
5.7
Constructeur de type fichier
Type fichier ::=
5.8
Constructeur de type chaîne
Type chaîne ::=
5.9
Constructeur de type pointeur
Type pointeur ::=
5.10 Constructeur de type ensemble
Type ensemble ::=
PROGRAMMATION PASCAL : 1. SYNTAXE DE PASCAL.
9
6.
Constantes
6.1
Constante
Constante ::=
6.2
Constante non signée
Constante non signée ::=
6.3
Constante chaîne
Constante chaîne ::=
6.4
Entier non signé
Entier non signé ::=
6.5
Nombre non signé
Nombre non signé ::=
Exemples :
… 1e4
… 3.1415926
… 314.15926E-2
… -1e-2…
7.
Éléments de base
7.1
Identificateur
Identificateur ::=
Un identificateur commence par une lettre suivie d'une combinaison quelconque de lettres, de chiffres
et du symbole _ .
Exemples :
… X …
… Nom_de_famille …
… A120b_1ab …
7.2
Lettre
Lettre ::=
Les lettres accentuées (é, à, ç, ö, ...) n'appartiennent pas à l'unité syntaxique Lettre.
7.3
Chiffre
Chiffre ::=
8.
Unités
8.1
Unité
Unité ::=
Une unité débute par le mot-clé unit suivi de son nom, d'un point virgule, d'une interface (partie
visible de l'extérieur), d’une implémentation (code Pascal de l'unité), d'une initialisation et se termine
par un point.
PROGRAMMATION PASCAL : 1. SYNTAXE DE PASCAL.
11
8.2
Interface
Interface ::=
L'interface contient la déclaration de tous les objets visibles (exportables) par l'inclusion de l'unité
dans le contexte d'une autre unité ou d'un programme (clause uses) ; les procédures et fonctions sont
décrites (bloc) dans la partie interface.
8.3
Implémentation
Implémentation ::=
L'interface contient le code Pascal des procédures et fonctions exportables et de tous les objets non
visibles de l'extérieur.
8.4
Partie initialisation
En BORLAND Pascal, il possible d'adjoindre à l'unité une séquence d'instructions exécutée une
seule fois (pour permettre, par exemple, l’initialisation de variables globales).
Initialisation ::=
Liste des unités syntaxiques
Affectation ...................................................... 3.3
Annonce de procédure ............................................. 2.8
Appel de fonction ................................................ 2.8
Appel de procédure ............................................... 3.4
Bloc ............................................................. 3.4
Chiffre .......................................................... 7.3
Constante ........................................................ 6.1
Constante chaîne ................................................. 6.3
Constante non signée ............................................. 6.2
Contexte ......................................................... 1.2
Déclaration de constante(s) ...................................... 2.2
Déclaration de procédure ......................................... 2.5
Déclaration de type(s) ........................................... 2.3
Déclaration de variable(s) ....................................... 2.4
Déclarations ..................................................... 2.1
En-tête de procédure ............................................. 2.6
Ensemble ......................................................... 4.7
Entier non signé ................................................. 6.4
Expression ....................................................... 4.1
Expression simple ................................................ 4.2
Facteur .......................................................... 4.4
Identificateur ................................................... 7.1
Implémentation ................................................... 8.3
Initialisation ................................................... 8.4
Instruction ...................................................... 3.2
Instruction alternative .......................................... 3.5
Instruction de choix ............................................. 3.6
Instruction de parcours d'intervalle scalaire .................... 3.7.3
Instruction répéter .............................................. 3.7.2
Instruction répétitive ........................................... 3.7
Instruction tant que ............................................. 3.7.1
Instructions ..................................................... 3.1
Interface ........................................................ 8.2
Lettre ........................................................... 7.2
Nombre non signé ................................................. 6.5
Paramètres ....................................................... 2.7
Programme ........................................................ 1.1
Sélection ........................................................ 3.8
Sous-ensemble .................................................... 4.8
Terme ............................................................ 4.3
Type ............................................................. 5.1
Type chaîne ...................................................... 5.8
Type énuméré ..................................................... 5.4
Type enregistrement .............................................. 5.6
Type ensemble .................................................... 5.10
Type fichier ..................................................... 5.7
Type intervalle .................................................. 5.3
Type pointeur .................................................... 5.9
Type scalaire .................................................... 5.2
Type tableau ..................................................... 5.5
Unité ............................................................ 8.1
Variable ......................................................... 4.5
PROGRAMMATION PASCAL : 1. SYNTAXE DE PASCAL.
13
9.
Mots réservés (sous-ensemble)
and
do
forward
mod
program
to
while
array
downto
function
nil
record
type
with
begin
else
if
not
repeat
unit
case
end
implementation
of
set
until
const
file
in
or
string
uses
div
for
interface
procedure
then
var
10. Principaux identificateurs prédéfinis
10.1 Types
Char
Integer
LongInt
Real
Boolean
scal long
X
1
X
2
4
6
X
1
caractère
entier court
entier long
réel
logique
Min
Max
Chr(0)
-32768
-2147483648
2.9e-39
False
Chr(255)
32767
2147483647
1.7e38
True
Text
fichier texte
Le type Real permet 7 à 8 chiffres significatifs en base 10.
Codage
ASCII / ANSI
complément à 2
complément à 2
virgule flottante
ASCII / ANSI
10.2 Constantes
type
MaxInt
MaxLongInt
Pi
False
True
Input
Output
Integer
LongInt
Real
Boolean
Boolean
Text
Text
32767
2147483647
3.1415927…
faux
vrai
fichier d'entrée (saisie) usuel (clavier en mode console)
fichier de sortie (affichage) usuel (écran en mode console)
10.3 Fonctions de parcours de type scalaire
Succ (…)
Pred (…)
valeur suivante (si elle existe)
valeur précédente (si elle existe)
10.4 Fonctions de transfert entre types
Ord
Chr
Trunc
Round
type source
type scalaire
Integer
type réel
type réel
par exemple dans le cas d'un caractère :
Ord
Char
type résultat
Integer
Char
rang de la valeur dans le type
type entier
type entier
partie entière
valeur arrondie
Integer
code du caractère
10.5 Procédures et fonction d'entrée/sortie (fichiers texte)
Dans le cas des fichiers de type Text les procédures d'entrée/sortie peuvent être considérées comme
des « métaprocédures » (les paramètres peuvent être de n'importe quel type prédéfini et leur nombre peut
être variable —ce qui est interdit sur tout autre procédure—). Le premier paramètre indique le nom du
fichier concerné.
10.5.1 Lecture et écriture sur tout fichier Text ff
Read(ff, v1, …, vn)
Eof(ff)
Readln(ff)
lecture sur le fichier ff de la valeur des variables v1, …, vn
fonction booléenne de test de la fin du fichier ff
lecture du fichier ff jusqu'à la première fin de ligne (incluse)
écriture sur le fichier ff de la valeur des expressions e1, …, en
écriture d'un saut de ligne sur le fichier ff
Les écritures suivantes sont équivalentes :
Readln(ff, v1, …, vn)
Read(ff, v1, …, vn); Readln(ff)
Writeln(ff, e1, …, en)
Write(ff, e1, …, en); Writeln(ff)
Write(ff, e1, …, en)
Writeln(ff)
10.5.2 Initialisation de l'utilisation d'un fichier Text
Il est nécessaire d'associer (to assign : assigner) à la variable ff de type Text un fichier physique
<nf> qui est désigné par son chemin d'accès —path— dans le système d'exploitation utilisé exprimé par
une valeur —variable ou constante— de type string.
assignation de ff au fichier physique <nf>
Assign(ff, <nf>)
ouverture de ff (si assigné!) en lecture
Reset(ff)
ouverture de ff (si assigné!) en écriture
Rewrite(ff)
Exemples :
Assign(FData,'C:\TEMP\PASCAL\TPAS\DONNEES.TXT'); Reset(FData);
...
Assign(FResultat, NomFichier); Rewrite(FResultat);
10.5.3 Fin d'utilisation d'un fichier Text
La fermeture de fichier Text est un procédure importante dans un système d'exploitation : elle
permet de libérer ce fichier pour d'autres utilisations. Elle permet par ailleurs en mode écriture de générer
le marqueur de fin de fichier. En Pascal, cette procédure est souvent faite par défaut (sauf, en particulier si
le fichier est déclaré dans une procédure ou une fonction) : il est souhaitable de l'effectuer
systématiquement.
fermeture (fin d'utilisation) du fichier ff
Close(ff)
10.6 Cas particulier du « mode Console » (utilisation de l’unité WinText)
En mode Console (WinText) deux fichiers de type Text sont prédéfinis et initialisés
automatiquement :
Input initialisé en lecture et associé au clavier
Output initialisé en écriture et associé à la fenêtre d’exécution de WinText.
Les procédures d'entrée/sortie ont la même syntaxe en omettant la premier paramètre (nom du
fichier) :
10.6.1 Lecture sur Input (clavier)
Read(v1, …, vn)
Readln
lecture sur Input de la valeur des variables v1, …, vn
lecture sur Input jusqu'à la première fin de ligne (incluse)
10.6.2 Écriture sur Output (fenêtre Windows)
Write(e1, …, en)
Writeln
écriture sur Output de la valeur des expressions e1, …, en
écriture sur Output d'un saut de ligne
Les écritures suivantes sont équivalentes :
Readln(v1, …, vn)
Read(v1, …, vn); Readln
Writeln(e1, …, en)
Write(e1, …, en); Writeln
L’ordre de fin d’utilisation est généré automatiquement à la fin du programme.
PROGRAMMATION PASCAL : 1. SYNTAXE DE PASCAL.
15
II. UTILISATION DE BORLAND PASCAL
L’ensemble de l’environnement de développement BORLAND Pascal pour Windows nécessaire
pour les T.P. de programmation A.S. (Structures d’algorithmes et de données) est contenu dans le
répertoire Pascal.
La dernière mise à jour de BORLAND-Pascal datant de 1993 (Windows 3.1) ; ce logiciel ne reconnaît
que les noms de répertoires et fichiers courts (8 caractères de type D.O.S.).
1.
Contenu du répertoire Pascal
Le répertoire Pascal contient 4 sous-répertoires :
1) Exec
(0.97 Mo)
Répertoire contenant tous les fichiers permettant l’utilisation de BORLAND Pascal soit :
Bpw.exe
exécutable BORLAND Pascal
Tpw.tpl
bibliothèque de base
Bwcc.dll
bibliothèques dynamiques Windows
Pbrowser.dll
-idTcolorcc.dll
-idBpw.cfg
fichier de configuration (options)
Bpw.dsk
-id2) Units
(297 K)
Répertoire contenant les unités nécessaires pour faire les T.P. (d'Année Spéciale) :
WinText.tpw
unité permettant le mode console.
WinTGr.tpw
unité permettant le mode graphique TurtleGraphics.
WinAppli.tpw
unité permettant la mise en œuvre d'applications Windows monofenêtre
(programmation événementielle)
Commdlg.tpw
unité permettant de générer les dialogues Windows.
ainsi que les fichiers d’aide Windows associés :
WinText.Hlp
WinTGr.Hlp
WinAppli.Hlp
WinText.Cnt
WinTGr.Cnt
WinAppli.Cnt
Le répertoire sera mis à jour au fur et à mesure des évolutions des unités et des choix pédagogiques.
3) Tools
Répertoire contenant :
PasToRTF.Exe
exécutable permettant de transformer un source pascal ('.Pas') en fichier
compatible Word ('.Rtf').
(12 K)
WorkShop. Répertoire contenant l'éditeur BORLAND de ressource Windows :
(2.67 Mo)
WorkShop.Exe
exécutable
WorkShop.Hlp
aide et les bibliothèques dynamiques Windows :
Worked1.dll Worked2.dll Worked3.dll Worked4.dll Worked5.dll Worklib1.exe Worklib2.exe
Oasis. Répertoire contenant l’éditeur d’aides Windows Oasis (freeware) :
OasisStd.exe
exécutable
OasisStd.hlp
aide
HcRtf.exe
compilateur d’aide Windows
4) Examples
Répertoire contenant des exemples sources ou exécutables.
(1.32 Mo)
2.
Installation de BORLAND Pascal
1) créer un répertoire Pascal sur C: (ou C:\Temp) dans lequel on copiera les 3 répertoires
Exec
Units
Tools
2) après exécution de Bpw.exe s'assurer que dans le menu :
- pour
Compile
on a bien
Target…
Windows
- pour
Options
dans
Directories
on a
Unit directories : c:\ ... \Pascal\units
3.
Description des unités Pascal
1) unité WinText.tpw. (version 1.3 3/10/2000).
L’unité WinText permet une mise en œuvre facile de programmes BORLAND Pascal pour
Windows (en mode dit «console») : création d’une fenêtre d’exécution associée aux fichiers Text
standards de Pascal (Input : procédures Read, Readln & Output : procédures Write, Writeln).
Deux procédures (sans paramètres) permettent d’obtenir dans un fichier Text (de nom ‘Echo.Txt’)
l’« écho » de tous les caractères affichés dans la fenêtre d’exécution d’un programme.
Possibilité de simuler un chronomètre pour évaluer le temps d’exécution (millisecondes).
2) unité WinTGr.tpw. (version 3.1 2/11/2000)
L’unité BORLAND Pascal WinTGr permet de d’exécuter des graphiques de type tortue
(TurtleGraphics) sous Windows comme dans le langage pédagogique Logo défini par Seymour Pappert.
Dans une fenêtre graphique d’exécution dont les coordonnées sont définies par des valeurs réelles par
rapport à son centre, les dessins sont obtenues en donnant des ordres à une tortue munie d’un crayon :
1. Poser ou lever le crayon (PenDown ou PenUp),
2. Avancer d’une longueur L (Forwd(L)),
3. Tourner d’un angle A exprimé en degrés (Turn(A)) suivant le sens trigonométrique,
3) unité WinAppli.tpw. (version 2.4 14/06/2001)
L’unité WinAppli permet de créer de petites applications graphiques dans une fenêtre d’exécution
dont les coordonnées sont définies (valeurs entières) à partir du sommet haut gauche de coordonnées
(0,0).
Le dessin est fait pour les traits (Line) avec un crayon (Pen) dont on peut modifier la largeur
(Width) et la couleur (Color) et pour les figures fermées : rectangle (Rect), ovale (Oval), rectangle à
coins arrondis (RoundRect). L’intérieur des figures fermées est rempli avec un pinceau (Brush) dont on
peut modifier la couleur (Color) ; si le pinceau est transparent (de couleur Null) seul le contour est
dessiné.
L’unité permet l’affichage de texte dont on peut modifier la taille et les attributs (style, couleur,
couleur de fond), la création de menus Windows, l’utilisation de boîtes de dialogue, …
L’unité permet de récupérer et gérer les principaux événements Windows (souris, clavier, menu,
sortie) (programmation événementielle).
L’unité permet l’utilisation de « dialogues fichiers ».
PROGRAMMATION PASCAL : 2. UTILISATION DE BORLAND PASCAL.
17
III. UNITÉ « WinText »
SOMMAIRE (WinText version 1.3)
L’unité BORLAND Pascal pour Windows WinText permet la mise en œuvre de programmes de type
« console » (saisie et affichage de texte en mode « conversationnel »).
1) Présentation de l'environnement WinText.
2) Initialisation, terminaison du mode WinText.
3) Écho dans un fichier Text.
4) Écho dans un fichier Text.
5) Exemple.
1.
Présentation
Sommaire
L'unité WinText permet une mise en œuvre facile de programmes BORLAND Pascal pour Windows
(en mode dit « console ») dans les environnements Windows 95/98/NT.
1) création d'une fenêtre d'exécution Windows associée aux fichiers Text standards de Pascal :
Input :
procédures Read, Readln
& Output :
procédures Write, Writeln.
2) deux procédures (sans paramètres) permettent d'obtenir dans un fichier Text (de nom 'Echo.Txt'
situé dans le même répertoire que le fichier source Pascal) l'écho de tous les caractères affichés
dans la fenêtre d'exécution du programme.
Pour arrêter l'exécution d'un programme ne répondant plus : appuyer simultanément sur les 3 touches
(Ctrl, Alt, Suppr) pour le fermer !
2.
Initialisation, terminaison du mode 'WinText'
Sommaire
La procédure
procedure InitWinText (Titre: string;
Width, Height: Integer);
permet l'initialisation du mode WinText et la création d'une fenêtre Texte d'en-tête Titre permettant de
contenir Height lignes de Width caractères (des valeurs nulles ou incorrectes provoquent la création
d'une fenêtre « standard » de 80 caractères de large et 100 caractères de hauteur).
La non-utilisation de InitWinText entraîne la création d'une fenêtre « standard » lors de l'exécution
d'une procédure de lecture, d'écriture (Read, Write, ...) ou d'InitEcho. Son titre porte alors le nom
complet (path) du programme Pascal.
La procédure
procedure DoneWinText;
permet la destruction de la fenêtre Texte.
La fenêtre d'exécution n'est pas détruite systématiquement à la fin du programme. L'appel de
DoneWinText permet de ne pas avoir à détruire « manuellement » l'application devenue INACTIVE.
La procédure
procedure ClrScr;
permet l'effacement du contenu la fenêtre WinText.
3.
Écho dans un fichier « texte »
Sommaire
Tous les caractères affichés sur la fenêtre d'exécution WinText peuvent être copiés dans un fichier
texte (Echo.Txt) à partir de l'appel de la procédure InitEcho jusqu'à l'appel de la procédure DoneEcho.
La procédure
procedure InitEcho;
entraîne le début de l'écho et la procédure
procedure DoneEcho;
permet la fin temporaire de l'écho (qui peut être repris par un nouvel appel de InitEcho). La fermeture
de la fenêtre d'exécution provoque la fermeture automatique du fichier écho.
Le fichier Echo.Txt peut être utilisé (et imprimé) par le Bloc-notes de Windows (Cf. Exemple).
4.
Gestion du temps
Sommaire
Pour évaluer les algorithmes par la comparaison du temps d'exécution des différents programmes
associés, on dispose de la procédure
procedure ResetTickCount;
permettant la remise à zéro d'un « chronomètre » simulé à l'aide de l'horloge interne, et de la fonction
function TickCount: LongInt;
permettant la récupération du temps écoulé depuis la précédente remise à zéro (exprimé en millièmes de
secondes)
Cf. Exemple
5.
Exemple
Sommaire
Le programme
{———————————————————DETERMINATION DE NOMBRES PARFAITS—————————————————————
Un nombre parfait est un entier non nul égal à la somme de ses diviseurs
d est diviseur de n <=> (d divise n) et (d<n)
}
program Nombres_Parfaits;
uses
WinText;
{————————————————————————————————————————————————————————AfficheDiviseurs
procédure permettant l'affichage de tous les diviseurs de l'entier Nbre}
procedure AfficheDiviseurs (Nbre: Integer);
var
D: Integer;
{diviseur}
begin
Write(Nbre : 12, ' = 1'); D := 2;
repeat
if Nbre mod D = 0 then Write('+', D : 1); D := D + 1
until D * 2 > Nbre;
Writeln
end;
{—————————————————————————programme principal————————————————————————————}
var
ValMax,
{valeur maximum recherchée}
Diviseur,
{diviseur possible}
Somme,
{somme des diviseur}
N: Integer;
{suite d'entiers positifs}
PROGRAMMATION PASCAL : 3. UNITÉ WinText.
19
begin
InitWinText('Nombres parfaits', 0, 0);
InitEcho;
Write('>> Valeur maximum = '); Readln(ValMax);
ResetTickCount;
N := 2;
repeat
Somme := 0; Diviseur := 1;
repeat
if N mod Diviseur = 0 then Somme := Somme + Diviseur;
Diviseur := Diviseur + 1
until Diviseur >= N;
if N = Somme then AfficheDiviseurs(N);
N := N + 1;
until N > ValMax;
Writeln(' durée = ', TickCount : 5, ' ms');
DoneEcho;
Writeln('C''est tout')
end.
permet (après une exécution) la création de la fenêtre
et du fichier Echo.Txt pouvant être lu avec le Bloc-notes de Windows :
Avec un algorithme plus efficace, le temps d'exécution d’un programme de recherche des nombres
parfaits peut être sensiblement « amélioré » (ramené à moins de 500 ms avec la même machine).
IV. UNITÉ « WinTGr »
SOMMAIRE (WinTGr version 3.1)
L’unité BORLAND Pascal pour Windows WinTGr permet la mise en œuvre de programmes
graphiques en mode « TurtleGraphics » (dessin de segments de droite, saisie et affichage de texte en
mode « conversationnel » dans une fenêtre graphique Windows 95/98/NT).
1) Présentation de l'environnement WinTGr.
2) Initialisation, terminaison du mode WinTGr.
3) Gestion de la tortue.
4) Saisie et affichage de Texte.
5) Miscellanées.
6) Exemple.
1.
Présentation
Sommaire
L'unité WinTGr permet d'exécuter du graphisme de type TurtleGraphics sous Windows comme dans
le langage à vocation pédagogique Logo défini par Seymour Pappert.
Dans une fenêtre graphique d'exécution dont les coordonnées (réelles) sont définies par rapport à
son centre (représentation mathématique usuelle du repère cartésien), les dessins sont obtenus en donnant
des ordres à une tortue munie d'un crayon : avancer (Forwd), tourner (Turn), lever le crayon (PenUp),
baisser le crayon (PenDown), …
À l'état initial la tortue se trouve à l'origine orientée suivant l'axe des x :
les 2 ordres successifs (le crayon étant supposé baissé !) :
Turn(45)
tourner de 45 degrés dans le sens trigonométrique (à gauche)
Forwd(300) avancer de 300 unités de longueur
provoquent le tracé du segment :
La tortue ici matérialisée en blanc n'est pas visible sur l'écran !
Les unités utilisées sont, pour les longueurs, la distance mesurée horizontalement entre 2 points
lumineux d'affichage (pixels) sur l'écran et pour les angles, le degré.
>> Initialisation, terminaison
PROGRAMMATION PASCAL : 4. UNITÉ WinTGr.
21
2.
Initialisation, terminaison
Sommaire
La procédure
procedure InitTurtle (Title: string;
Width, Height: Integer);
permet l'initialisation du mode WinTGr et la création d'une fenêtre graphique d'en-tête Title dont la taille
est définie par sa hauteur (Height) et sa largeur (Width) sont exprimées dans l'unité de mesure de
longueur utilisée (La longueur 1 correspondant à la distance entre deux points d'affichage ou pixels ; cette
distance étant évaluée sur les axes).
L'utilisation de valeurs nulles pour exprimer la taille provoque la création d'une fenêtre « standard »
; l'utilisation de valeurs trop grandes (i.e. MaxInteger) provoque la création d'une fenêtre maximale.
L'utilisation de cette procédure est obligatoire en début de programme.
La procédure
procedure DoneTurtle;
permet la destruction de la fenêtre d'exécution.
La fenêtre d'exécution n'est pas détruite systématiquement à la fin du programme. L'appel de
DoneWinTGr permet de ne pas avoir à détruire « manuellement » l'application devenue INACTIVE.
La procédure
procedure NewTurtle (Message: string);
permet l'effacement du contenu la fenêtre d'exécution, le positionnement de la tortue à l'origine dans l'état
initial et l'affichage de la chaîne Message dans le coin haut gauche de la fenêtre.
>> Présentation
3.
Gestion de la tortue
Sommaire
Le graphisme est obtenu par un crayon (Pen) dont on peut modifier les caractéristiques :
1) la couleur qui peut être choisie parmi les 16 couleurs de base
const
Black = 0;
Blue = 1;
Red = 4;
Magenta = 5;
DarkGray = 8; LightBlue = 9;
LightRed = 12; LightMagenta = 13;
type
TColor = Black..White;
Green = 2;
Cyan = 3;
Brown = 6;
LightGray = 7;
LightGreen = 10; LightCyan = 11;
Yellow = 14;
White = 15;
à l'aide de la procédure
procedure PenColor (Color: TColor);
la couleur par défaut (état initial) est noir (Black).
2) l'épaisseur du trait, à l'aide de la procédure
procedure PenWidth (Width: Integer);
l'épaisseur par défaut (état initial) est 1 (l'épaisseur du trait est égale à la valeur absolue de Width ; une
valeur nulle provoque un trait d'épaisseur 1).
3) l'activation du crayon est obtenue par les 2 procédures
procedure PenUp;
le crayon est levé (inactif) : les déplacements ne provoquent pas de « trace ».
procedure PenDown;
le crayon est posé (actif) ; c'est la valeur par défaut (état initial).
4) Le déplacement de la tortue est obtenu par les deux procédures
procedure Forwd (Long: Real);
la tortue avance de Long unités de longueur (une valeur négative provoque un recul de la tortue).
une sortie de la fenêtre d'exécution peut provoquer une erreur d'exécution !
procedure Turn (theta: Real);
la tortue tourne de theta degrés dans le sens trigonométrique ; une valeur positive provoque un virage à
gauche (et une valeur positive un virage à droite).
Un déplacement direct vers un point du plan est possible par la procédure
procedure GotoXY (x, y: Real);
4.
Saisie et affichage de Texte
Sommaire
1) la scrutation du clavier peut être faite par les 2 fonctions
function KeyPressed: Boolean;
permettant de vérifier si une touche du clavier a été enfoncée.
function ReadKey: Char;
permettant de récupérer le caractère de la touche enfoncée.
La fonction ReadKey provoque une attente de frappe de touche (sauf si KeyPressed est égal à True).
L'appel régulier de KeyPressed dans un programme permet de rendre actif la possibilité d'interrompre
l'exécution.
2) la saisie d'une chaîne de caractères peut être faite par la procédure
procedure ReadString (x, y: Real;
Prompt: string;
var Result: string);
le programme attend la saisie d'une chaîne de caractères après l'affichage de Prompt, la coordonnée du
point (x,y) correspond au coin haut gauche du premier caractère de Prompt. Le résultat est récupéré dans
Result.
3) l'affichage d'une chaîne de caractères peut être fait par la procédure
procedure OutString (x, y: Real;
Message: string);
le point (x,y) correspond au coin haut gauche du premier caractère affiché de Message.
4) la taille des caractères affichés (dépendant du mode graphique) exprimée en pixels, peut être
obtenue par les 2 fonctions
function XChar: Integer;
function YChar: Integer;
5.
Miscellanées
Sommaire
1) Il est possible de récupérer des informations sur la position de la tortue dans la fenêtre
graphique par les fonctions
function Angle: Real;
orientation de la tortue (degrés / axe des x)
function WhereX: Real;
coordonnée x de la tortue
function WhereY: Real;
coordonnée y de la tortue
function InWindow: Boolean;
permet de vérifier si la tortue est visible !
2) la position de la tortue peut être forcée par la procédure
procedure Position (x, y, theta: Real);
les nouvelles coordonnées de la tortue sont (x,y) et son orientation theta degrés / axe des x.
3) les valeurs maximales visibles pour les x et y dans la fenêtre d'exécution peuvent être obtenues
par les 2 fonctions
PROGRAMMATION PASCAL : 4. UNITÉ WinTGr.
23
function XMax: Integer;
function YMax: Integer;
4) il est possible de sauvegarder dans une pile (stack) l'état de la tortue par la procédure
procedure SaveTurtle;
puis de le récupérer par la procédure
procedure RestoreTurtle;
5) Il est possible de générer l'alerte sonore système par la procédure
procedure Beep;
et de générer une attente exprimée en millisecondes par la procédure
procedure Wait (Time: LongInt);
6.
Exemple
Sommaire
Le programme
program Turtle;
uses
WinTGr;
{—————————————————————————————————————————————————— choix d'une couleur}
procedure ChoixCouleur (var Couleur: TColor);
var
i, Err: Integer;
x, y: Real;
StCoul: string;
{chaîne de lecture de la réponse}
begin
NewTurtle('Couleurs prédéfinies');
PenWidth(yChar); x := xMax/2; y := yMax/9;
for i := 0 to 15 do
begin
Str(i: 2, StCoul);
{conversion d'un nombre en type string}
OutString(-x-xChar*4, yMax-(y*(i+1)) + yChar/2, StCoul);
Position(-x, yMax-(y*(i+1)), 0); PenColor(i); Forwd(2*x);
end;
ReadString(-100, -YMax+YChar, 'Choix de couleur : ', StCoul);
Val(StCoul, Couleur, Err);
{conversion d'une chaîne en nombre}
end;
{———————————————————————————————————————————————————dessin d'une rosace}
procedure Rosace (Taille: Real;
Couleur: TColor);
var
i, j :Integer;
d: Real;
begin
NewTurtle('Rosace'); Pencolor(Couleur); PenWidth(2);
d := Taille*0.6;
for i := 1 to 10 do
begin
Turn(-36); for j := 1 to 5 do begin Forwd(d); Turn(72) end;
end;
end;
{—————————————————————————programme principal————————————————————————————}
var
ValC: TColor;
{couleur choisie}
begin
InitTurtle('Essai WinTGr', 420, 420);
ChoixCouleur(ValC);
Rosace(yMax, ValC);
OutString(xMax-11*xChar, -yMax+yChar, 'C''est tout!');
Beep; ReadKey; DoneTurtle
end.
permet (après une exécution) la création de la fenêtre
puis l'affichage
PROGRAMMATION PASCAL : 4. UNITÉ WinTGr.
25
V. UNITÉ « WinAppli »
SOMMAIRE (WinAppli version 2.3)
L’unité BORLAND Pascal pour Windows WinAppli permet de créer des applications Windows
(graphiques) monofenêtre en programmation « événementielle ».
1)
2)
3)
4)
5)
6)
7)
8)
9)
1.
Présentation de l'Environnement graphique.
Initialisation du mode WinAppli (création de la fenêtre).
Gestion des Menus déroulants Windows.
Gestion des Événements Windows.
Création d'une Boîte modale de dialogue.
Appel d'un fichier d'aide.
Utilisation de procédures utilitaires (Miscellanées).
Saisie de texte.
Utilisation de Dialogues fichiers.
PRÉSENTATION GÉNÉRALE
1.1
Environnement graphique
Sommaire
L'Initialisation du mode WinAppli provoque la création d'une fenêtre d'exécution dont les
coordonnées (de l'intérieur) sont des valeurs entières exprimées en pixels et définies à partir du sommet
haut gauche de coordonnées (0, 0) :
Le contexte graphique d'affichage est défini par 3 objets :
1) le crayon (pen) qui permet de définir le tracé les lignes (droites) et dont on peut modifier la
couleur (PenColor) et l'épaisseur (PenWidth).
2) le pinceau (brush) qui permet de définir le contenu des figures fermées et dont on peut modifier
la couleur (BrushColor).
3) la police de caractères (font) qui permet l'affichage de texte ; il est possible d’en modifier la
couleur (TextColor), le style (TextStyle) et la couleur de fond (TextBkColor).
Il lui correspond des Types et valeurs par défaut.
L'affichage se fait par les Fonctions graphiques.
1.2
Fonctions & procédures graphiques
Sommaire
Les procédures et fonctions graphiques permettent :
1) une Modification du contexte d'affichage : crayon (pen), pinceau (brush) ou caractères (text),
2) de tracer une Ligne droite,
3) de dessiner une Figure fermée,
4) de récupérer la taille (utilisable) de la Fenêtre graphique et d'en effacer le contenu,
5) d'afficher des points (Pixels),
6) de sauvegarder, récupérer et afficher des images (Bitmap),
7) d'afficher du Texte.
1.3
Types prédéfinis & valeurs par défaut
Sommaire
Les couleurs de base définies de la manière suivante :
const
Null = -1;
{couleur "transparente"}
Black = 0;
Blue = 1;
Green = 2;
Cyan = 3;
Red = 4;
Magenta = 5;
Brown = 6;
LightGray = 7;
DarkGray = 8; LightBlue = 9;
LightGreen = 10; LightCyan = 11;
LightRed = 12; LightMagenta = 13; Yellow = 14;
White = 15;
Les types prédéfinis sont
type
TColor = Null..White;
TFontStyle = set of (Bold, Italic, Underline);
>>> Cf. Texte
TReply = (Yes, No, Cancel);
>>> Cf. Boîte modale de dialogue
Les valeurs initiales sont pour le crayon :
PenColor(Black);
PenWidth(1);
pour le pinceau :
BrushColor(Null);
et pour le texte :
TextColor(Black);
BkColor(White);
TextHeight(16);
TextStyle([]);
Ces valeurs peuvent être personnalisées par la Modification du contexte.
1.4
Modification du contexte d’affichage
Environnement graphique
1.4.1
Crayon (pen)
La couleur du crayon peut être modifiée par
procedure PenColor(Color: TColor);
et l'épaisseur de trait (exprimée en pixels) par
procedure PenWidth(Width: Integer);
PROGRAMMATION PASCAL : 5. UNITÉ WinAppli.
27
1.4.2
Pinceau (brush)
La couleur de remplissage (des figures fermées) peut être modifiée par
procedure BrushColor(Color: TColor);
1.4.3
Texte
La taille (hauteur des caractères en pixels –16 par défaut–) peut être modifiée par
procedure TextSize (Height: Integer);
la couleur des caractères par
procedure TextColor (Color: TColor);
la couleur d'affichage du fond de texte par
procedure TextBkColor (Color: TColor);
et le style par
procedure TextStyle (Style: TFontStyle);
Exemple :
TextColor(Red); TextStyle([Bold, Underline]);
caractères rouges, gras & soulignés.
TextBkColor(Null); TextStyle([]);
caractères « normaux » avec fond transparent (l'affichage précédent n'est pas « effacé »).
1.4.4
Sauvegarde et restauration du contexte graphique (ensemble des valeurs
précédentes).
procedure SaveContext;
procedure RestoreContext;
>>> Types et valeurs par défaut.
2.
FONCTIONNALITÉS
2.1
Initialisation
Sommaire
L'initialisation du mode WinAppli est fait par l'appel de la procédure :
procedure InitAppli (Title: string;
Width, Height: Integer);
qui provoque la création d'une fenêtre graphique d'en-tête Title de hauteur Width et de largeur Height
(exprimées en pixels). La valeur 0 entraîne la définition de la taille par défaut et la valeur MaxInt la taille
maximale (l'appel de cette procédure est obligatoire pour créer une fenêtre).
Une fois la fenêtre créée, il est possible de lui associer des Menus déroulants.
L'appel de cette procédure alors qu'une fenêtre graphique est déjà créée provoque la destruction de
cette fenêtre et de ses attributs (Titre, Menus, ...) puis la création d'une nouvelle fenêtre (pouvant être
d'une taille différente) dont il faudra, le cas échéant, recréer les attributs.
La procédure
procedure DoneAppli;
de terminaison du mode WinAppli est implicite et exécutée systématiquement à la fin du programme.
2.2
Menus déroulants
Sommaire
Les menus de la fenêtre principale sont repérés par leur numéro d'ordre (≥1) ; à chaque menu de
nom Name est associé une liste déroulante (PopUp) des choix possibles représentée sous la forme d'une
chaîne de caractères : chaque sous menu est séparé du suivant par un point virgule. Chaque sous menu est
repéré par son numéro d'ordre (SubMenu).
2.2.1
Ajout d'un menu.
procedure AddMenu (Name, PopUp: string);
Exemple :
InitAppli('Répertoire', 0, 0);
AddMenu('Fichier', 'Nouveau;;Ouvrir;Sauver;Sauver sous…;;Fermer');
AddMenu('Etat','Consultation;;Saisie;Modification;Suppression');
AddMenu('?', 'Aide de Répertoire;;A propos ...');
Les valeurs associées aux menus sont 1 pour 'Fichier', 2 pour 'Etat' et 3 pour '?'. Les valeurs
des sous menus (SubMenu) associés à 'Fichier' sont : 1 pour 'Nouveau', 2 pour 'Ouvrir', ..., 5
pour 'Fermer'.
2.2.2
Activation ou désactivation du sous menu de rang SubMenu du menu de rang Menu
procedure ActiveMenu (Menu, SubMenu: Integer;
Enable: Boolean);
2.2.3
Affichage ou non d'une marque (« coche ») en face du sous menu de rang SubMenu
du menu de rang Menu
procedure MarkMenu (Menu, SubMenu: Integer;
Check: Boolean);
Exemple :
ActiveMenu(1, 3, False);
MarkMenu(2, 2, True);
La récupération des choix dans les menus est faite par le gestionnaire d'Événements.
2.3
Événements
Sommaire
Les événements pouvant être interceptés par WinAppli sont caractérisés par le type
type
TEvent = (eNull, eQuit, eMenu, eKeyboard, eMouseLB, eMouseRB);
eNull
pas d'événement depuis le dernier appel de la fonction NewEvent
eQuit
une demande pour quitter l'application a été détectée
eMenu
événement Menu : choix d'un sous menu (actif)
eKeyboard
événement Clavier : une touche a été pressée
eMouseLB
événement Souris : le bouton gauche a été pressé
eMouseRB
événement Souris : le bouton droit a été pressé
ils sont récupérés par l'appel de la fonction
function NewEvent: TEvent;
PROGRAMMATION PASCAL : 5. UNITÉ WinAppli.
29
Les informations sur le dernier événement (récupéré) peuvent être obtenues par l'appel des
procédures
2.3.1
récupération du caractère correspondant à la touche pressée :
procedure GetChar (var Key: Char);
2.3.2
récupération du code géographique correspondant à la touche pressée :
procedure GetKeyCode (var KeyCode: Integer);
2.3.3
récupération du rang du sous menu correspondant au menu sélectionné :
procedure GetMenu (var Menu, SubMenu: Integer);
2.3.4
récupération des coordonnées de la souris (lors du dernier événement Souris) :
procedure GetMouseLoc (var x, y: Integer);
Exemple de répétition de scrutation des événements :
repeat
case NewEvent of
eMenu : ...
eKeyboard : ...
eQuit : FinAppli := WarningBox(2, 'Confirmer quitter')=Yes
end
until FinAppli
3.
PROCÉDURES GRAPHIQUES
3.1
Fenêtre graphique
Fonctions Graphiques
L'effacement de la fenêtre graphique peut être effectué par l'appel de la procédure
procedure EraseWindow;
La taille utilisable (de l'intérieur) de la fenêtre graphique, exprimée en pixels peut être obtenue
par les deux fonctions
function xWindow: Integer;
function yWindow: Integer;
La création de menus entraîne une modification de yWindow.
Il est possible de modifier la taille de la fenêtre par la procédure InitAppli ; mais ses attributs
seront alors réinitialisés et ses menus supprimés. (>> Initialisation).
3.2
Ligne droite
Fonctions Graphiques
La procédure
procedure DrawLine (x1, y1, x2, y2: Integer);
effectue le tracé d'une ligne (droite) allant du point (x1, y1) au point (x2, y2) avec le crayon actif (couleur
et épaisseur).
3.3
Figures fermées
Fonctions Graphiques
Les figures fermées sont définies par rapport à une zone rectangulaire de la fenêtre déterminée par
les coordonnées du point haut gauche (x1, y1) et du point bas droit (x2, y2). Le contour est effectué avec
le crayon actif (Pen) et l'intérieur est rempli avec le pinceau actif (Brush).
3.3.1
Tracé d'un rectangle
procedure DrawRect (x1, y1, x2, y2: Integer);
3.3.2
Tracé d'un rectangle à coins arrondis
procedure DrawRoundRect (x1, y1, x2, y2, R: Integer);
le rayon de l'arrondi est R exprimé en pixels.
3.3.3
Tracé d'un ovale inscrit dans un rectangle
procedure DrawOval (x1, y1, x2, y2: Integer);
3.4
Texte
Fonctions Graphiques
Le texte est affiché avec la police fixe « Courier New » : tous les caractères d'une même taille ont la
même largeur. Il est possible d'en modifier la taille (hauteur), la couleur, la couleur du fond et le style
(gras, souligné, italique) ; Cf. Modification du contexte.
La procédure
procedure DrawString (x, y: Integer;
Message: string);
permet l'affichage de Message à partir de (x, y) = coordonnée du point haut gauche du premier caractère.
Il est possible de récupérer (pour calculer la taille des messages affichés) les largeur et hauteur
effectives d'un caractère (y compris l'espacement) par les fonctions :
function xText: Integer;
function yText: Integer;
La chaîne de caractère Message peut être obtenue à partir d'une expression Value de type numérique
(Integer, LongInt, Real, ...) par la procédure
procedure Str (Value: <type numérique>[: Longueur [:nombre de décimales]];
var Message: string);
on associe à Value des formats comme dans les ordres de lecture (Read) sur fichier Text.
Exemple :
Str(Val: 12: 6, StrVal); DrawString(10, 10, StrVal);
Il est possible de faire de la Saisie de texte par la procédure ReadString.
3.5
Pixel
Fonctions Graphiques
L'affichage dans la fenêtre graphique d'exécution est composé de pixels (points). Ces pixels sont
normalement affichés par les procédures de dessin.
Ils peuvent, aussi, être affichés (un par un) par les deux procédures :
3.5.1
Affichage d'un point d'une couleur donnée
procedure DrawPixel (x, y: Integer;
Color: TColor);
3.5.2
Affichage d'un point de couleur calculée par la fonction système RGB (Red Green
Blue)
procedure DrawPixRGB (x, y: Integer;
R, G, B: Byte);
3.5.3
Récupération de la couleur RGB (Red Green Blue) d’un point affiché sur la fenêtre
procedure GetPixRGB (x, y: Integer;
var R, G, B: Byte);
PROGRAMMATION PASCAL : 5. UNITÉ WinAppli.
31
3.6
Bitmap
Fonctions Graphiques
Les bitmaps correspondent à un rectangle d'affichage sur la fenêtre (un rectangle est défini par son
point haut gauche et son point bas droit).
Le logiciel permet de mémoriser jusqu'à kMaxImages (=64) bitmaps par l'appel de la procédure
procedure GetImage (Numero, top, left, bottom, right: Integer);
la bimap correspondant au rectangle (délimité par top, left, bottom, right) affiché sur la fenêtre
est repérée par son Numero (devant être compris entre 1 et kMaxImage).
La bitmap peut alors être affichée par l'appel de la procédure
procedure PutImage (Numero, top, left: Integer);
Les bitmaps peuvent être récupérées à partir d'un fichier ressource par la procédure
procedure LoadImage (Numero: Integer;
Name: string);
qui correspond au chargement de la bitmap de nom Name se trouvant dans un fichier ressource ('*.Res')
inclus au programme par la commande de compilation: {$R <nom du fichier> : l'image correspondante
est repérée comme dans GetImage par Numero et peut être affichée par PutImage.
4.
PROCÉDURES UTILITAIRES
4.1
Boîte modale de dialogue
Sommaire
Il est possible d'afficher des boîtes d'alerte système pouvant comporter de 1 à 3 boutons ; la réponse
étant caractérisée par le type TReply (Cf. Types et valeurs par défaut) ; ils sont récupérés par l'appel de la
fonction permettant l'affichage d'une boîte de dialogue d'alerte ayant Num boutons de réponse et contenant
la chaîne Message
function WarningBox (Num: Integer;
Message: string): TReply;
le résultat de l'appel est
Yes
No
Cancel
si le bouton « Oui » ou « OK » a été pressé,
si le bouton « Non » a été pressé (Num = 2 ou 3),
si le bouton « Annuler » a été pressé (Num = 3).
Exemples :
WarningBox(1, Concat('Jeu de Taquin v1.2',#13,'08/02/2000'))
WarningBox(2, 'Fin du test')=Yes
1
2
WarningBox(3, 'Enregistrer les modifications ...')=Cancel
3
4.2
Appel d’un fichier d’aide
Sommaire
Il est possible d'appeler un fichier d'aide Windows95 (créé par exemple par le freeware Oasis) par
les appels des procédures :
procedure ExecHelp (HelpName: string);
procedure DoHelpContext (HelpName: string;
Context: Integer);
permettant l'exécution de l'aide Windows (WinHelp) avec le fichier de nom HelpName (devant avoir le
suffixe '*.Hlp'). La procédure DoHelpContext permet d'afficher directement le premier item de l'aide ayant
le numéro de contexte Context.
Exemples :
ExecHelp('Essai');
DoHelpContext('Essai', 1);
L'exécution de WinHelp peut être « terminée » par l'appel de la procédure
procedure DoneHelp;
Il est possible d'exécuter un programme Windows (>Miscellanées ).
4.3
Saisie de « texte »
Sommaire
L'édition d'une chaîne de caractères, par saisie au clavier, peut être faite par la procédure
procedure EditString(x, y, Long: Integer;
Local: Boolean;
var Result: string);
qui provoque l'affichage de la chaîne Result dans un rectangle délimitant sa taille maximum (déterminée
par Long). Le point (x, y) correspond au coin haut gauche du premier caractère. L'édition peut être faite
par le clavier en utilisant les touches de contrôle :
Inser
basculement en mode « overwrite » ou « insert » (par défaut)
Suppr
suppression du caractère à droite du curseur
Début
positionnement du curseur au début
Fin
positionnement du curseur en fin.
la souris peut être utilisée pour déplacer le curseur d'édition (bouton gauche). Si le booléen Local est égal
à True, la chaîne résultante doit être validée par la touche Entrée sinon elle peut aussi être validée par un
clic du bouton gauche de la souris à l'extérieur du rectangle d'édition.
La lecture d'une chaîne de caractères (précédée de l'affichage de Prompt) peut être faite par la
procédure
procedure GetString(x, y: Integer;
Prompt: string;
var Result: string;
Long: Integer);
(fonctionne sur le même principe que EditString, Local et Result étant respectivement initialisés à
True et à '')
Exemple :
GetString(10, 10, '
Nom du client ', NomCl, 40);
GetString(10, 30, 'Prénom du client ', PreCl, 30);
>>> Affichage de Texte .
PROGRAMMATION PASCAL : 5. UNITÉ WinAppli.
33
La chaîne de caractères obtenue Result peut être traduite en une variable Value de type numérique
(Integer, LongInt, Real, ...) par la procédure
procedure Val (Result: string;
var Value: <type numérique>;
var Code: Integer);
Code contient le résultat de la transcodification (0 si pas d'erreur sinon sa valeur indique le rang du
caractère où été détectée la première erreur).
Exemple :
repeat
GetString(10, 10, ' x = ', StrX, 20);
Val(StrX, x, Erreur);
until Erreur=0;
4.4
Miscellanées
Sommaire
4.4.1
Exécution d'un programme Windows (*.Exe)
La procédure
procedure ExecFile (CommandLine: string);
provoque l'exécution de la ligne de commande CommandLine.
Exemple :
ExecFile('Winhlp32 Essai.hlp');
4.4.2
Génération de l'alerte sonore système
procedure Beep;
4.4.3
Simulation d'un « chronomètre »
La remise à zéro du chronomètre est effectuée par la procédure
procedure ResetTickCount;
La fonction
function TickCount: LongInt;
permet la récupération du temps écoulé depuis la précédente remise à zéro (exprimé en millièmes de
secondes).
4.4.4
Ajout de la chaîne Name en fin du titre de la fenêtre Windows (permet par exemple
d'afficher le nom du fichier en cours d'utilisation)
procedure SetEndTitle (Name: string);
Exemple :
SetEndTitle(Concat('"', NameOfFile(Path), '"'));
5.
DIALOGUES « FICHIERS »
5.1
Dialogues « Fichiers »
Sommaire
Il est possible d’utiliser des dialogues modaux Windows pour récupérer les noms complets DOS
(paths) de fichiers en parcourant la hiérarchie des répertoires accessibles (comme en utilisant le menu
Fichier et les sous menus Ouvrir… ou Enregistrer sous… de la plupart des logiciels!).
Cette unité permet deux types de dialogues :
1) Dialogue Ouvrir ... pour récupérer le nom d'un fichier existant,
2) Dialogue Enregistrer sous … pour récupérer le chemin complet (path) où sauver un fichier.
5.2
Dialogue Ouvrir…
Dialogues Fichiers
La détermination du nom complet D.O.S. (path) d'un fichier existant peut être effectué par l'appel
de la fonction
function OpenFile (Mask: string;
var Path: string): Boolean;
création d'une fenêtre de dialogue dans laquelle n'apparaîtront que les fichiers correspondant au masque.
La fonction retourne True si on sort de la fenêtre de dialogue par une validation, on récupère, alors, dans
Path le chemin (nom DOS) du fichier sélectionné par l'utilisateur.
Exemple :
if OpenFile('*.bsp', NomFich) then
begin
Assign(Fichier, NomFich);
Reset(Fichier);
…
La fonction
function NameOfFile (var Path: string): string;
retourne le nom (court) du fichier correspondant à Path.
5.3
Dialogue Enregistrer sous…
Dialogues Fichiers
La détermination du nom complet D.O.S. (path) d'un fichier à partir de son nom court peut être
effectué par la fonction
function SaveFile (Mask: string;
var Path: string): Boolean;
création d'une fenêtre de dialogue dans laquelle apparaîtront les répertoires menant à Path.
La fonction retourne True si on sort de la fenêtre de dialogue par une validation; on récupère, alors,
dans Path le nom complet D.O.S. du fichier dont le répertoire a été sélectionné (Path doit être initialisé
avant l'appel de la fonction, la valeur correspondante pouvant être ou non modifiée par l'utilisateur).
Exemple :
NomFich := 'MONSTRE.BSP';
if SaveFile('*.BSP', NomFich) then
begin
Assign(Fichier, NomFich);
Rewrite(Fichier);
…
PROGRAMMATION PASCAL : 5. UNITÉ WinAppli.
35
La fonction
function ExistFile (var Path: string): Boolean;
permet de vérifier l'existence du fichier correspondant à Path et, par exemple, de demander confirmation
(de la modification du fichier) à l'utilisateur en utilisant une Boîte modale de dialogue
VI. LISTE DES PROCÉDURES & FONCTIONS PRÉDÉFINIES
procedure ActiveMenu (Menu, SubMenu: Integer; Enable: Boolean);
unité
Page
WinAppli
29
WinAppli
28
WinTGr
23
WinTGr
WinAppli
WinAppli
24
34
27
WinText
19
WinAppli
33
WinAppli
28
WinText
19
WinAppli
33
WinTGr
22
WinText
18
WinAppli
30
WinAppli
31
WinAppli
31
WinAppli
31
WinAppli
30
WinAppli
31
WinAppli
31
WinAppli
33
WinAppli
30
WinAppli
34
WinAppli
33
WinAppli
36
WinTGr
22
WinAppli
30
Activer ou désactiver un menu
procedure AddMenu (Name, PopUp: string);
Ajouter un menu un menu à la barre de menus
function
Angle: Real;
Récupérer l’angle de la tortue avec l’axe des x
procedure Beep;
Générer un bip sonore
procedure BrushColor (Color: TColor);
Définir la couleur du pinceau
procedure ClrScr;
Effacer le contenu de la fenêtre texte
procedure DoHelpContext (HelpName: string; Context: Integer);
Exécution d’un fichier d’aide Windows (.hlp)
procedure DoneAppli;
Fin d’application
procedure DoneEcho;
Fin d’écho
procedure DoneHelp;
Fin d’aide
procedure DoneTurtle;
Fin d’application
procedure DoneWinText;
Fin d’application
procedure DrawLine (x1, y1, x2, y2: Integer);
Tracé d’une ligne
procedure DrawOval (x1, y1, x2, y2: Integer);
Tracé d’un ovale inclus dans un rectangle
procedure DrawPixel (x, y: Integer; Color: TColor);
Tracé d’un point
procedure DrawPixRGB (x, y: Integer; R, G, B: Byte);
Tracé d’un point
procedure DrawRect (x1, y1, x2, y2: Integer);
Tracé d’un rectangle
procedure DrawRoundRect (x1, y1, x2, y2, R: Integer);
Tracé d’un rectangle à coins arrondis
procedure DrawString (x, y: Integer; Message: string);
Affichage d’une chaîne de caractères
procedure EditString (x, y, Long: Integer; Local: Boolean;
var Result: string);
Édition d’une chaîne de caractères tapée au clavier
procedure EraseWindow;
Effacement de la fenêtre graphique
procedure ExecFile (CommandLine: string);
Exécution d’un fichier (.Exe)
procedure ExecHelp (HelpName: string);
function
Exécution d’un fichier d’aide Windows (.Hlp)
ExistFile (Path: string): Boolean;
Vérification de l’existence d’un fichier
procedure Forwd (Long: Real);
Faire avancer la tortue
procedure GetChar (var Key: Char);
Récupérer un caractère tapé au clavier
PROGRAMMATION PASCAL : 6. LISTE DES PROCÉDURES ET FONCTIONS PRÉDÉFINIES.
37
procedure GetImage (Numero, top, left, bottom, right: Integer);
WinAppli
32
WinAppli
30
WinAppli
30
WinAppli
30
WinAppli
31
WinAppli
33
WinTGr
22
WinAppli
28
WinTGr
19
WinAppli
22
WinText
18
WinTGr
23
WinTGr
23
WinAppli
32
WinAppli
29
WinAppli
35
WinAppli
29
WinTGr
22
WinAppli
35
WinTGr
23
WinTGr
WinAppli
WinTGr
22
27
22
WinTGr
22
WinTGr
WinAppli
WinTGr
22
27
23
WinAppli
32
WinTGr
23
WinTGr
23
WinText
WinAppli
WinAppli
19
34
28
WinTGr
24
Sauver une bitmap affichée dans la fenêtre
procedure GetKeyCode (var KeyCode: Integer);
Récupérer le code géographique d’une touche du clavier
procedure GetMenu (var Menu, SubMenu: Integer);
Récupérer les numéros des menu et sous menu sélectionnés
procedure GetMouseLoc (var x, y: Integer);
Récupérer la position de la souris
procedure GetPixRGB (x, y: Integer; var R, G, B: Byte);
Récupération de la « couleur » d’un point
procedure GetString (x, y: Integer; Prompt: string;
var Result: string; Long: Integer);
Lire une chaîne tapée au clavier
procedure GotoXY (x, y: Real);
Déplacement de la souris
procedure InitAppli (Title: string; Width, Height: Integer);
Création d’une application Windows monofenêtre
procedure InitEcho;
Début d’écho
procedure InitTurtle (Title: string; Width, Height: Integer);
Création d’une application
procedure InitWinText (Title: string; Width, Height: Integer);
Création d’une application
function
InWindow: Boolean;
Vérification de la présence de la tortue dans la fenêtre
function
KeyPressed: Boolean;
Vérification de la pression d’une touche
procedure LoadImage (Numero: Integer; Name: string);
Sauver une bitmap à partir d’un fichier ressource (*.Res)
procedure MarkMenu (Menu, SubMenu: Integer; Check: Boolean);
Marquer ou « démarquer » un menu
function
NameOfFile (var Path: string): string;
Récupérer le nom court d’un fichier
function
NewEvent: TEvent;
Récupérer un événement Windows
procedure NewTurtle;
Réinitialiser l’état de la tortue
function
OpenFile (Mask: string; var Path: string): Boolean;
Récupérer le nom long d’un fichier (existant) avec une boîte de dialogue
procedure OutString (x, y: Integer; Message: string);
Affichage d’une chaîne de caractères
procedure PenColor (Color: TColor);
Modification de la couleur du crayon
procedure PenDown;
Rendre le crayon actif
procedure PenUp;
Rendre le crayon inactif
procedure PenWidth (Width: Integer);
Modification de l’épaisseur du crayon
procedure Position (x, y, theta: Real);
Modifier la position de la tortue
procedure PutImage (Numero, top, left: Integer);
Afficher une bitmap (précédemment sauvée)
function
ReadKey: Char;
Récupérer un caractère tapé au clavier
procedure ReadString (x, y: Integer; Prompt: string;
var Result: string);
Lire une chaîne tapée au clavier
procedure ResetTickCount;
Remettre le chronomètre à zéro
procedure RestoreContext;
Restaurer le contexte graphique (précédemment sauvé)
procedure RestoreTurtle;
Restaurer l’état de la tortue (précédemment sauvé)
procedure SaveContext;
WinAppli
28
WinAppli
35
WinTGr
24
WinAppli
34
Sauver le contexte graphique
function
SaveFile (Mask: string; var Path: string): Boolean;
Récupérer le nom long d’un fichier avec une boîte de dialogue
procedure SaveTurtle;
Sauver l’état de la tortue
procedure SetEndTitle (Name: string);
Modifier la fin de titre de la fenêtre
procedure Str (Value: <type numérique>; var Message: string);
31
Transcodification d’une valeur numérique en chaîne de caractères
function
Sqrt (X: Real): Real;
Calcul de la racine carrée
procedure TextBkColor (Color: TColor);
WinAppli
28
WinAppli
28
WinAppli
28
WinAppli
28
WinText
WinAppli
WinTGr
19
34
22
Modifier la couleur du fond de texte
procedure TextColor (Color: TColor);
Modifier la couleur du texte
procedure TextSize (Height: Integer);
Modifier la taille du texte
procedure TextStyle (Style: TFontStyle);
Modifier le « style » du texte
function
TickCount: LongInt;
Récupérer la valeur du chronomètre
procedure Turn (Theta: Real);
Modifier l’angle de la tortue
procedure Val (Result: string; var Value: <type numérique>;
var ErrorCode: Integer);
33
Transcodification d’une chaîne de caractères en valeur numérique
procedure Wait (Time: LongInt);
WinTGr
24
WinAppli
32
WinTGr
23
WinTGr
23
WinTGr
23
WinTGr
24
WinAppli
31
WinAppli
30
WinTGr
23
WinTGr
24
WinAppli
31
WinAppli
30
Générer une attente
function
WarningBox (Num: Integer; Message: string): TReply;
function
WhereX: Real;
function
WhereY: Real;
Générer une boîte de dialogue
Récupérer l’abscisse de la tortue
Récupérer l’ordonnée de la tortue
function
xChar: Integer;
Récupérer la largeur d’un caractère
function
xMax: Integer;
Récupérer la valeur maximum pour x
function
xText: Integer;
Récupérer la largeur d’un caractère
function
xWindow: Integer;
Récupérer la largeur de la fenêtre
function
yChar: Integer;
Récupérer la hauteur d’un caractère
function
yMax: Integer;
function
yText: Integer;
function
yWindow: Integer;
Récupérer la valeur maximum pour y
Récupérer la hauteur d’un caractère
Récupérer la hauteur de la fenêtre
PROGRAMMATION PASCAL : 6. LISTE DES PROCÉDURES ET FONCTIONS PRÉDÉFINIES.
39