CyBWarrior

1. Initialisation
2. Dessiner
3. Styles de lignes
4. Couleurs et remplissage
5. Obtenir les états

Turbo Pascal n’est pas limité au seul affichage de texte. Il peut également utiliser des fonctions graphiques
qui lui permettent de réaliser des dessins plus ou moins sophistiqués.
La totalité de ces fonctions sont situées dans l’unité graph.

Initialisation

Avant toute utilisation des fonctions graphiques, il faut initaliser le système avec l’instruction InitGraph.
La syntaxe est la suivante :

InitGraph(Pilote, Mode, Chemin);

• Pilote représente le pilote graphique de la machine
• Mode correspond au mode graphique
• Chemin est l’emplacement du répertoire BGI sur votre machine

Les 2 premiers arguments doivent être des variables. Les valeurs que peut prendre Pilote sont les suivantes :

Constantes	Valeurs	Constantes	Valeurs
Detect	0	IBM8514	6
CGA	1	HercMono	7
MCGA	2	ATT400	8
EGA	3	VGA	9
EGA64	4	PC3270	10
EGAMono	5

Detect permet de réaliser une auto-détéction (voir plus loin).
Pour les modes graphique, ce peut être une des valeurs suivantes :

Constantes	Valeurs	Résolutions	Constantes	Valeurs	Résolutions
CGAC0	0	320 x 200	EGALo	0	640 x 200
CGAC1	1	320 x 200	EGAHi	1	640 x 350
CGAC2	2	320 x 200
CGAC3	3	320 x 200	EGA64Lo	0	640 x 200
CGAHi	4	640 x 200	EGA64Hi	1	640 x 350
MCGAC0	0	320 x 200	ATT400C0	0	320 x 200
MCGAC1	1	320 x 200	ATT400C1	1	320 x 200
MCGAC2	2	320 x 200	ATT400C2	2	320 x 200
MCGAC3	3	320 x 200	ATT400C3	3	320 x 200
MCGAMed	4	640 x 200	ATT400Med	4	640 x 200
MCGAHi	5	640 x 480	ATT400Hi	5	640 x 400
EGAMonoHi	3	640 x 350	IBM8514Lo	0	640 x 480
HercMonoHi	0	720 x 348	IBM8514Hi	1	1024 x 768
VGALo	0	640 x 200	PC3270Hi	0	720 x 350
VGAMed	1	640 x 350
VGAHi	2	640 x 480

Le mode utilisé doit correspondre au pilote utilisé (logique), sauf si vous utiliser l’auto-détéction (voir plus loin).
Voici un exemple :

Uses Graph;
VarPilote : Integer;{Variable pour le pilote}
Mode : Integer;{Variable pour le mode}
begin
Pilote := VGA;
Mode := VGAHi;
InitGraph(Pilote, Mode, 'c:\outils\tp\bgi');
CloseGraph;
end.

Vous remarquez que l’on a utiliser l’instruction CloseGraph. CloseGraph doit être appelé à chaque fois en fin de programme.
Il désactive le mode graphique et permet de libérer les divers secteur de mémoire occupés par les méthodes graphques.
Pour réaliser une auto-détection, il suffit d’utiliser Detect pour le pilote. La variable Mode n’a plus besoin d’être
initialisée :

Uses Graph;
VarPilote : Integer;
Mode : Integer;
begin
Pilote := Detect;
InitGraph(Pilote, Mode, 'c:\outils\tp\bgi');
CloseGraph;
end.

Dessiner

Après avoir initialisé le système, il devient enfin possible d’utiliser les fonctions graphiques.
Les fonctions regroupées dans le tableau ci-dessous sont celles permettant de tracer des formes quelconques
à l’écran.

Fonctions de dessin

Fonction	Description
Arc	Dessine un arc de cercle à l’écran. X et Y representent le centre de l’arc, AngleDeb est l’angle de départ de l’arc, AngleFin celui de fin et Rayon le rayon de l’arc. Les angles sont exprimés en degrès. Syntaxe : Arc(X, Y: Integer; AngleDeb, AngleFin, Rayon: Word);
Bar	Dessine un rectangle plein. x1 et y1 represente le coin supérieur gauche et x2 et y2 le coin inférieur droit. La couleur et le style de remplissage est défini par SetFillStyle ou SetFillPattern (voir plus loin). Syntaxe : Bar(x1, y1, x2, y2: Integer);
Bar3D	Réalise la même chose que Bar, mais en 3D. Profond represente la taille en pixel du contour. Les valeurs possible pour Top sont les constantes TopOn (true) et TopOff (false). Si Top vaut TopOn, alors une face supérieure est dessinée. Syntaxe : Bar3D(x1, y1, x2, y2: Integer; Profond: Word; Top: Boolean);
Circle	Dessine un cercle de centre X et Y, et de rayon Rayon. Syntaxe : Circle(X, Y: Integer; Rayon: Word);
DrawPoly	Dessine un polygone vide de NbPoints sommets. Les coordonnées de ces sommets sont définis dans la variable PolyPoints du type PointType. Syntaxe : DrawPoly(NbPoints: Word; var PolyPoints); Exemple : Uses Graph; ConstFrance : array[1..9] of PointType = ((X:0; Y:20), (X:100; Y:0), (X:200; Y:20), (X:150; Y:150), (X:200; Y:280), (X:100; Y:300),(X:0; Y:280), (X:50; Y:50), (X:0; Y:20)); VarPilote : Integer; Mode : Integer; begin Pilote := Detect; InitGraph(Pilote, Mode, 'c:\outils\tp\bgi'); DrawPoly(SizeOf(France) div SizeOf(PointType), France); CloseGraph; end.
Ellipse	Dessine une ellipse de centre X et Y. AngleDeb et AngleFin representent les angles de début et de fin, en degrès. XRayon et YRayon representent la distance entre le centre et la tangente verticale et la tangente horizontale. Syntaxe : Ellipse(X, Y: Integer; AngleDeb, AngleFin: Word; XRayon, YRayon: Word);
FillEllipse	Réalise la même chose que Ellipse, mais remplit la forme. Il n’y a donc pas d’angles de départ et de fin. Syntaxe : FillEllipse(X, Y: Integer; XRayon, YRayon: Word);
FillPoly	Réalise la même chose que DrawPoly, mais remplit le polygone. Syntaxe : FillPoly(NbPoints: Word; var PointsPoly);
Line	Trace une ligne du point x1 et y1 au point x2 et y2. Syntaxe : Line(x1, y1, x2, y2: Integer);
LineRel	Trace à une ligne à partir de la position du curseur graphique (voir plus loin). Dx et Dy represente la distance sur X et sur Y à parcourir à partir de la position du curseur graphique. Syntaxe : LineRel(Dx, Dy: Integer);
LineTo	Trace à une ligne à partir de la position du curseur graphique, jusqu’au point de coordonnées X et Y. Syntaxe : LineTo(X, Y: Integer);
MoveRel	Déplace le curseur graphique de Dx pixels sur l’axe des X et de Dy pixels sur l’axe des Y. Syntaxe : MoveRel(Dx, Dy: Integer);
MoveTo	Déplace le curseur graphique à la positon X et Y. Syntaxe : MoveTo(X, Y: Integer);
PieSlice	Réalise la même chose que Arc, mais remplit la forme. Syntaxe : PieSlice(X, Y: Integer; AngleDeb, AngleFin, Rayon: Word);
PutPixel	Dessine un point au coordonnées X et Y de couleur Pixel. Syntaxe : PutPixel(X, Y: Integer; Pixel: Word);
Rectangle	Trace un rectangle du coin supérieur gauche de coordonnées x1 et y1, au coin inférieur droit de coordonnées x2 et y2. Syntaxe : Rectangle(x1, y1, x2, y2: Integer);
Sector	Réalise la même chose que Ellipse, mais remplit la forme. Contrairement à FillEllipse, il est possible de spécifier un angle. Syntaxe : Sector(x, y: Integer; AngleDeb, AngleFin, XRayon, YRayon: Word);

Styles de lignes

Par défaut, les figures énoncées ci-dessus sont tracées avec des lignes pleines. Mais il est possible de modifier
ce comportement. Il faut pour cela utiliser SetLineStyle, dont voici la syntaxe :

SetLineStyle(Style, Motif, Epaisseur: Word);

Style represente le style de ligne à appliquer. Ce peut être une des valeurs suivantes :

Styles de lignes

Index	Constante	Description
0	SolidLn	Trait plein
1	DottedLn	Pointillés
2	CenterLn	Trait mixte
3	DashedLn	Trait tireté
4	UserBitLn	Définit par l’utilisateur

Motif n’est utilisé que si le parametre Style est à UserBitLn.
Dans ce cas, il vous faudra fournir un entier codé sur 16 bits (Word). Chaque bit
de ce nombre représentera alors un pixel. Si le bit est à 1, le pixel sera affiché, si il est
à 0 il sera eteint.
Ainsi, si Motif vaut 61901, on aura :

1111000111001101

Ce qui pourai être symbolisé grossierement par :

____   ___  __ _

Epaisseur represente…l’épaisseur de la ligne. Ce peut être une des valeurs suivantes :

Constantes d’épaisseur

Index	Constante	Description
1	NormWidth	Trait normal
3	ThickWidth	Trait épais

Couleurs et remplissage

Toutes ces fonctions tracent des formes suivant les couleurs et le style de remplissage sélectionné. Pour séléctionner
une couleur, on utilise la procédure SetColor, associée à l’index de la couleur séléctionnée.
Voici un rappel des couleurs disponibles :

Index	Constante	Aperçu
0	Black
1	Blue
2	Green
3	Cyan
4	Red
5	Magenta
6	Brown
7	LightGray
8	DarkGray
9	LightBlue
10	LightGreen
11	LightCyan
12	LightRed
13	LightMagenta
14	Yellow
15	White

Par exemple, pour tracer un cercle rouge, on écrira :

Uses Graph;
VarPilote : Integer;
Mode : Integer;
begin
Pilote := Detect;
InitGraph(Pilote, Mode, 'c:\outils\tp\bgi');
SetColor(Red);{Premier plan rouge}
Circle(50, 50, 50);
CloseGraph;
end.

Il est également possible de définir une couleur de fond avec SetBkColor :

Uses Graph;
VarPilote : Integer;
Mode : Integer;
begin
Pilote := Detect;
InitGraph(Pilote, Mode, 'c:\outils\tp\bgi');
SetColor(Red);{Premier plan rouge}
SetBkColor(LightGreen);{Arrière plan vert-pale}
Circle(50, 50, 50);
CloseGraph;
end.

Comme vu dans le tableau plus haut, certaines fonctions autorisent le remplissage des figures, comme par
exemple FillPoly ou FillEllipse.
Avant de faire appel à l’une de ces fonctions, il faut d’abord définir le style de remplissage. On utilise
alors SetFillStyle.
Voici la syntaxe de SetFillStyle :

SetFillStyle(Pattern, Couleur: Word);

Couleur represente la couleur de remplissage et Pattern le motif, qui peut être une des valeurs
ci-dessous :

Motifs de remplissage

Index	Constante	Description
0	EmptyFill	Couleur du fond (transparent)
1	SolidFill	Couleur du tracé
2	LineFill	Lignes horizontales
3	LtSlashFill	Slashs
4	SlashFill	Slashs épais
5	BkSlashFill	Anti-Slashs épais
6	LtBkSlashFill	Anti-Slashs
7	HatchFill	Quadrillage
8	XHatchFill	Quadrillage en diagonales
9	InterleaveFill	Ecailles de poissons
10	WideDotFill	Points espacés
11	CloseDotFill	Points sérés
12	UserFill	Motif définit par l’utilisateur (voir plus loin)

Par exemple, pour tracer un rectangle bleu clair en ecailles de poisson, on écrira :

Uses Graph;
VarPilote : Integer;
Mode : Integer;
begin
Pilote := Detect;
InitGraph(Pilote, Mode, 'c:\outils\tp\bgi');
SetFillStyle(InterLeaveFill, LightBLue);
Bar(0, 0, 300, 100);
CloseGraph;
end.

Vous remarquez que le dernier motif UserFill peut-être personalisé. Pour créer un motif utilisateur,
il faut utiliser SetFillPattern dont la syntaxe est la suivante :

SetFillPattern(Pattern: FillPatternType; Couleur: Word);

Pour Couleur, pas de problèmes. Pour FillPatternType en revanche, ça se complique.
Le type FillPatternType est le suivant :

FillPatternType = ARRAY[1..8] OF BYTE;

On voit que c’est un tableau de 8 octets (BYTE).
Un motif est en fait un carré de 8×8 pixels. Selon le motif
sélectionné, on affiche ou non un pixel.
Chaque octet de FillPatternType represente une ligne de ce carré de 8×8. Et dans un octet, il y a
8 bits (voir la numération). Chaque bit de cet octet représente un pixel de la ligne :
quand il est à 1, on affiche le pixel, quand il est à 0, on l’éteint.
Par exemple, essayons de créer comme motif le symbole @ (ça va pas être si dur que ça ). Tout
d’abord écrivons nos 8 octets :

0 0 1 1 1 1 0 0-> 60
0 1 0 0 0 0 1 0-> 66
1 0 1 1 1 1 0 1-> 189
1 0 1 0 0 1 0 1-> 165
1 0 1 0 0 1 1 0-> 166
1 0 1 1 1 1 0 0-> 188
0 1 0 0 0 0 1 0-> 66
0 0 1 1 1 1 0 0-> 60

Nous pouvons donc maintenant définir notre motif et le tester :

Uses Graph;
Const
Arob : FillPatternType = (60, 66, 189, 165, 166, 188, 66, 60);
VarPilote : Integer;
Mode : Integer;
begin
Pilote := Detect;
InitGraph(Pilote, Mode, 'c:\outils\tp\bgi');
SetFillPattern(Arob, White);
Bar(0, 0, 300, 100);
CloseGraph;
end.

Ok, ce n’est pas très joli. Si vous en faites des plus beau, envoyez les moi.

En dehors des fonctions qui permettent un remplissage automatique, il est aussi possible de remplir des formes
fermées, un peu comme avec un logiciel d’infographie.
Pour cela, il faut utiliser FloodFill. FloodFill remplit une surface du point X et Y
jusqu’à ce que la couleur Bord soit rencontrée.
Voici la syntaxe :

FloodFill(X, Y: Integer; Bord: Word);

Obtenir les états

Pour programmer plus facilement, le Turbo Pascal dispose de plusieurs fonctions permettant au programmeur
de connaitre les états de plusieurs parametres. Voici ces fonctions :

Fonction	Description
GetArcCoords	Modifie la variable ArcCoords du type ArcCoordsType transmise en argument avec les coordonnées transmises à Arc lors de son dernier appel. Voici le type ArcCoordsType : ArcCoordsType = RECORD X, Y, Xstart, Ystart, Xend, Yend : INTEGER; END;
GetBkColor	Renvoi l’index de la couleur de fond d’écran utilisée.
GetColor	Renvoi l’index de la couleur de premier plan utilisée.
GetDriverName	Renvoi une chaîne de caractères renvoyant le nom du pilote graphique utilisé.
GetFillPattern	Modifie la variable FillPattern transmise en argument avec le motif de remplissage defini par l’utilisateur avec SetFillPattern.
GetFillSettings	Modifie la variable FillInfo transmise en argument avec les informations de remplissage courant. Voici le type FillSettingsType : FillSettingsType = RECORD Pattern : WORD; Color : WORD; END;
GetGraphMode	Renvoi l’index du mode graphique utilisé.
GetLineSettings	Modifie la variable LineInfo transmise en arguments avec les informations de style de ligne courant.
GetMaxColor	Renvoi l’index de la couleur la plus haute pouvant être utilisé.
GetMaxMode	Renvoi l’index du mode graphique le plus haut pouvant être utilisé avec le pilote courant.
GetMaxX	Renvoi le numéro de la colonne le plus à droite (autrement dit, la largeur de l’écran).
GetMaxY	Renvoi le numéro de la ligne la plus basse (autrement dit, la hauteur de l’écran).
GetModeName	Renvoi une chaîne de caractère représentant le nom du mode graphique correspondant à l’index transmis en argument.
GetModeRange	Modifie les variables ModeInf et ModeSup transmises en argument avec respectivement le plus petit et le plus grand index utilisables par le pilote spécifié comme mode graphique. Syntaxe : GetModeRange(PiloteGraph: Integer; var ModeInf, ModeSup:Integer);
GetPixel	Renvoi la couleur du pixel situé aux coordonnées X et Y. Syntaxe : GetPixel(X, Y: Integer): Word;
GetX	Renvoi la position X du curseur graphique
GetY	Renvoi la position Y du curseur graphique

Series Navigation

«Turbo Pascal – Le sonTurbo Pascal – L’unité Graph et le texte»