|
|
|
Turbo Pascal - Graphismes
|
Autre langage disponible pour cet article : 
Rubrique : Turbo Pascal
lundi 25 mars 2002 18:42
|
Voir les commentaires pour Turbo Pascal - Graphismes
|
- Initialisation
- Dessiner
- Styles de lignes
- Couleurs et remplissage
- 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 machineMode correspond au mode graphiqueChemin 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 8x8 pixels. Selon le motif
sélectionné, on affiche ou non un pixel.
Chaque octet de FillPatternType represente une ligne de ce carré de 8x8. 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
|
|
Voir les commentaires pour Turbo Pascal - Graphismes
|
|
|
|
Accueil
Membres
Forum
Articles
Download
Sondages
Outils
Scriptland
ProgBoards
