10- Modes graphiques et unité Graph

Lorsqu'on allume un PC, son écran fonctionne en mode texte. Cela signifie qu'on peut le considérer comme un tableau de 25 lignes et de 80 colonnes, chaque case pouvant contenir un caractère. Si le PC est muni d'une carte graphique et de l'écran correspondant celui-ci pourra fonctionner en mode graphique. Il pourra alors être considéré comme un tableau de points (ou pixels). Le nombre de points par ligne et par colonne étant beaucoup plus important que le nombre de caractères du mode texte, on pourra obtenir des images et des dessins à l'écran.

L'unité Graph de Turbo Pascal contient des procédures, fonctions, constantes et variables concernant la gestion de l'écran en mode graphique.

Elle permet :

• le passage du mode texte au mode graphique et réciproquement.
• les dessins de points et de lignes.
• les remplissages de surfaces.
• l'affichage de texte dans différentes polices.
• la capture d'images.

Passage en mode graphique

Les principaux modes graphiques supportés

L'unité Graph permet d'utiliser les modes graphiques suivants :

• CGA (mode abandonné à cause de sa faible résolution et du nombre de couleurs réduit à 4 )
• EGA 16 couleurs avec une résolution de 640 sur 350.
• VGA 16 couleurs avec une résolution de 640 sur 480.
• EGA ou VGA à 2 couleurs.

La procédure InitGraph

Pour gérer tous ces modes graphiques, Turbo Pascal utilise des pilotes graphiques qui sont contenus dans des fichiers indépendants d'extension BGI. Un programme Turbo Pascal utilisant l'unité Graph ne pourra fonctionner que s'il a accès au fichier BGI qui lui est nécessaire. Il s'agit en général de CGA.BGI et de EGAVGA.BGI.

C'est la procédure InitGraph qui permet d'installer un mode graphique.

Syntaxe :

 InitGraph(Var Pilote,Mode:Integer;Chemin:String);

• Pilote et mode sont des entiers indiquant le driver et le mode graphique utilisé.
• Chemin est une chaîne de caractères indiquant le chemin d'accès aux fichiers BGI (une chaîne vide représente le répertoire courant).

En donnant la valeur Detect (constante égale à 0) on charge Turbo Pascal de tester la configuration matérielle et de choisir le meilleur mode graphique possible. Sinon, on peut utiliser les constantes prédéfinies suivantes :

Pilotes graphiques
  CGA           = 1;            EGA     = 3;
  HercMono      = 7;            VGA     = 9;
Modes graphiques
  EGAHi	        = 1;  { 640x350 16 couleurs 2 pages }
  EGAMonoHi     = 3;  { 640x350 noir et blanc 2 pages }
  HercMonoHi    = 0;  { 720x348 noir et blanc 2 pages }
  VGAHi         = 2;  { 640x480 16 couleurs 1 page }

La fonction GraphResult

La procédure InitGraph peut échouer pour diverses raisons : configuration matérielle insuffisante pour le mode demandé, fichiers BGI introuvables, mémoire insuffisante, ... La fonction GraphResult qui renvoie un code d'erreur permet de savoir si le passage en mode graphique a pu être réalisé correctement. On pourra utiliser les constantes prédéfinies suivantes :

  grOk = 0;  { pas d'erreur }
  grFileNotFound  =  -3;  { fichier absent }

De toute façon, un résultat différent de grOk (=0) indique que le programme ne peut pas continuer.

Retour au mode texte

Lorsqu'un mode graphique est installé, le retour en mode en mode texte peut s'effectuer à l'aide des deux procédures suivantes :

• CloseGraph : restaure le mode actif avant InitGraph et libère la mémoire occupée par le driver graphique. La sortie est donc "définitive". Cette procédure sera utilisée nécessairement à la fin du programme.
• RestoreCrtMode : permet de restaurer provisoirement le mode actif avant InitGraph; le driver BGI reste en mémoire.

Points, coordonnées, couleurs

Le système de coordonnées écran

Lorsque le mode graphique est installé, il est possible d'accéder à chaque point de l'écran et de lui donner une couleur. L'accès aux points se fait par l'intermédiaire de 2 coordonnées dans le système défini par les données suivantes :

• le coin supérieur gauche de l'écran a les coordonnées (0,0).
• le coin inférieur droit de l'écran a les coordonnées (maximum de x, maximum de y).

Les valeurs maximales de x et de y dépendent du mode graphique choisi, elles peuvent être obtenues grâce aux fonctions GetMaxX et GetMaxY.

La procédure PutPixel

PutPixel(x,y:Integer;Col:Word);

Cette procédure affiche un point de couleur Col aux coordonnées (x,y). En mode 16 couleurs, Col peut prendre l'une des valeurs suivantes déclarées comme constantes :

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;

La fonction GetPixel

Function GetPixel(x,y:Integer) : Word;

Cette fonction renvoie le numéro de la couleur actuelle du point de coordonnées (x,y).

La couleur de fond

Le fond de l'écran a une couleur unique qui est le noir après l'appel de InitGraph.

• La procédure SetBkColor(Col) permet d'attribuer la couleur Col au fond.
• La fonction GetBkColor renvoie le numéro de couleur actuelle du fond.
• La procédure ClearDevice efface l'écran avec la couleur de fond courante.

Tracé de segments

Paramètres de dessin

Lorsqu'on dessine un segment, différents paramètres peuvent intervenir :

• la couleur
• le style
• l'épaisseur
• le mode de tracé.

Ces paramètres sont définis de façon implicite dans des variables gérées par l'unité Graph. Plusieurs procédures permettent de les modifier selon les besoins.

La procédure SetColor et la fonction GetColor

• Procedure SetColor(Col:Word); permet de définir la couleur Col comme couleur de tracé.
• Function GetColor:Word; renvoie le numéro de la couleur de tracé active.

La procédure SetLineStyle

SetLineStyle(Style,Motif,Epaisseur:Word); 

Elle définit le style, le motif et l'épaisseur du trait.

Le style est défini par l'une des constantes suivantes :

SolidLn   = 0;  { trait plein } DottedLn   = 1;  { Trait pointillé }
CenterLn  = 2;  { Trait mixte } DashedLn   = 3;  { Trait tireté }
UserBitLn = 4;  { Style défini par l'utilisateur }

Le motif est un masque définissant un style personnel de trait. Il n'est pris en compte que si Style est égal à UserBitLn.

L'épaisseur peut prendre les deux valeurs NormWidth = 1 et ThickWidth = 3.

La procédure SetWriteMode.

SetWriteMode(Mode:Integer);

Elle permet de choisir entre plusieurs modes de tracés :

• Mode CopyPut (CopyPut=0) : l'affichage se fait sans tenir compte du fond de l'écran.
• Mode XOrPut (XOrPut=1) : l'affichage se fait en combinant la couleur du trait et la couleur du fond avec l'opération XOr. L'intérêt de ce mode est qu'il permet d'effacer une ligne en la traçant une seconde fois avec la même couleur.

Paramètres par défaut

Après l'appel de InitGraph, la couleur par défaut est le blanc, le style est trait plein, l'épaisseur est 1 et le mode de tracé est CopyPut.

Les procédures Line et Rectangle

• Line(x1,y1,x2,y2:Integer); cette procédure trace un segment entre les points de coordonnées (x1,y1) et (x2,y2). Elle utilise les paramètres de tracé courants.
• Rectangle(x1,y1,x2,y2:Integer); cette procédure trace un rectangle dont la diagonale est définie par les points (x1,y1) et (x2,y2). Elle utilise les paramètres de tracé courants.

La position courante pour les tracés

L'unité Graph gère un point courant qui permet de diminuer le nombre de paramètres pour certaines procédures. Après InitGraph, ce point est en (0,0). On peut obtenir les coordonnées du point courant en utilisant les fonctions GetX et GetY qui renvoient des entiers de type Integer.

On peut modifier la position du point courant en utilisant la procédure MoveTo(x,y) où x et y sont des entiers de type Integer indiquant la position choisie ou la procédure MoveRel(DepX,DepY) où DepX et DepY sont des entiers de type Integer indiquant un déplacement relatif.

Note : le point courant est invisible; sa position peut être modifiée par certaines procédures.

Les procédures LineTo et LineRel

• LineTo(X,Y:Integer); cette procédure trace un segment allant du point courant au point (X,Y). Elle utilise les paramètres de tracé courants. Elle place ensuite le point courant en (X,Y).
• LineRel(DepX,DepY:Integer); cette procédure trace un segment allant du point courant jusqu'à une position définie par les déplacements relatifs DepX et DepY. Elle utilise les paramètres de tracé courants.

Ecriture de textes

Paramètres d'affichage du texte

Les fonctions d'affichage de texte utilisent un certain nombre de paramètres implicites comme la direction, la taille, la police, le mode de justification. Deux procédures permettent de les définir. La couleur d'affichage est celle définie par la procédure SetColor déjà rencontrée.

La procédure SetTextJustify

SetTextJustify(Horiz,Verti:Word);

Cette procédure définit le type de justification horizontale et verticale. Les paramètres Horiz et Verti prendront leurs valeurs parmi les constantes suivantes :

LeftText  = 0; { texte aligné à gauche }  CenterText = 1; { texte centré }
RightText = 2; { texte aligné à droite }  BottomText = 0; { texte aligné vers le bas }
TopText   = 2; { texte aligné vers le haut }

Les valeurs par défaut sont LeftText et BottomText.

La procédure SetTextStyle

SetTextStyle(Police,Direction,Taille:Word);

Cette procédure définit la police, la direction et la taille des caractères utilisés.

Police peut prendre les valeurs définies par les constantes suivantes :

DefaultFont = 0;  { caractères en matrices 8x8 }	
TriplexFont = 1;  SmallFont  = 2;  SansSerifFont = 3;  GothicFont = 4;

Direction peut prendre les valeurs :

HorizDir   = 0; { de gauche à droite }   VertDir = 1; { de haut en bas }
Le paramètre Taille doit être compris entre 1 et 10.

Les valeurs par défaut sont DefaultFont, HorizDir et 1.

Les procédures d'affichage de texte

• OutText(Chaine:String); cette procédure affiche la chaîne de caractères Chaine à la position du point courant. Elle modifie la position de ce point.
• OutTextXY(x,y:Integer;Chaine:String); cette procédure affiche la chaîne de caractères Chaine à la position (x,y).

Les fonctions calculant la longueur et la hauteur d'une chaîne.

• TextHeight(Chaine:String):Word; cette fonction renvoie la hauteur de la partie d'écran occupée par Chaine lors d'un affichage dans le style courant.
• La fonction TextWidth(Chaine:String):Word; cette fonction renvoie la longueur de la partie d'écran occupée par Chaine lors d'un affichage dans le style courant.

Le remplissage de surfaces

Les styles de remplissage

Le remplissage de surfaces peut se faire suivant plusieurs styles.

La procédure SetFillStyle(Motif,Col:Word) permet de définir le style (Motif) et la couleur (Col) utilisés par les procédures de remplissage.

Motif prendra sa valeur dans les constantes prédéfinies suivantes.

EmptyFill=0; {couleur du fond}     SolidFill=1;  {teinte unie}	
LineFill=2;  { --- }               LtSlashFill=3;  { /// }
SlashFill=4;  { /// épais }        BkSlashFill=5;  { \\\ épais }
LtBkSlashFill=6; { \\\ }           HatchFill=7;  {hachures fines}
XHatchFill=8; {hachures épaisses}  InterleaveFill=9; {lignes entrelacées}
WideDotFill=10; {trame de points aérée}	
CloseDotFill=11; {trame de points serrée}
UserFill = 12; { motif défini par l'utilisateur }

Deux procédures de remplissage

• La procédure Bar(x1,y1,x2,y2:Integer); cette procédure remplit le rectangle défini par les extrémités (x1,y1) et (x2,y2) de sa diagonale.
• La procédure FloodFill(x,y:Integer;Bord:Word); cette procédure remplit la surface contenant le point (x,y) et limitée par la couleur Bord.

Traitement des images

L'unité Graph fournit 2 procédures et une fonction permettant de sauver et de restituer des parties d'écran.

La fonction ImageSize

ImageSize(x1,y1,x2,y2:Integer):Word; cette fonction renvoie la taille en octets nécessaire à la sauvegarde de la partie d'écran limitée par le rectangle défini par (x1,y1) et (x2,y2).

Note : cette taille ne doit pas dépasser 64 Ko ce qui correspond en mode VGAHi à un peu plus d'un quart d'écran.

La procédure GetImage

GetImage(x1,y1,x2,y2:Integer; Image:Pointer); cette procédure copie la partie d'écran définie par le rectangle (x1,y1) et (x2,y2) dans une zone mémoire désignée par le pointeur Image.

Note : il appartient au programmeur de réserver la mémoire nécessaire.

La procédure PutImage

PutImage(x,y:Integer;Image:Pointer;Oper:Word); cette procédure permet d'afficher à la position (x,y) de l'écran une image préalablement sauvée en mémoire dans la zone indiquée par le pointeur Image. Le paramètre Oper permet de préciser comment l'affichage de l'image tiendra compte du fond. On pourra utiliser les constantes suivantes :

NormalPut = 0;  { MOV }        CopyPut = 0;   { MOV }
XORPut    = 1;  { XOR }        OrPut   = 2;   { OR  }
AndPut    = 3;  { AND }	       NotPut  = 4;   { NOT }

Conclusion sur l'unité Graph

Cette étude ne se veut pas exhaustive, de nombreuses procédures et fonctions de l'unité Graph n'ont pas été évoquées comme par exemple la gestion des fenêtres graphiques, des palettes de couleurs, des pages écran...

Le programme BGIDEMO.PAS fourni avec Turbo Pascal donne une idée de l'ensemble des possibilités de l'unité Graph.

Les cartes VGA permettent d'utiliser un mode graphique à 256 couleurs de résolution 320 sur 200. L'unité Graph ne permet pas d'utiliser ce mode. Le programmeur devra créer d'autres moyens permettant de le gérer.

Chapitre précédent
Chapitre suivant