Section courante

A propos

Section administrative du site

Utilisation de l'interface graphique Borland

L'unité Graph propose une bibliothèque complète de plus de 50 routines graphiques allant des appels de haut niveau tels que SetViewPort, Circle, Bar3D et DrawPoly, à des routines orientées bits telles que GetImage et PutImage. Il prend en charge plusieurs styles de remplissage et de ligne et il existe plusieurs polices de caractères pouvant être agrandies, justifiées et orientées horizontalement ou verticalement.

Pour compiler un programme utilisant l'unité Graph, vous aurez besoin du code source de votre programme, du compilateur et d'un accès aux unités standard dans la bibliothèque d'exécution (TURBO.TPL) et l'unité Graph (GRAPH.TPU) : Pour exécuter un programme utilisant l'unité Graph, vous aurez besoin d'un ou plusieurs pilotes graphiques (fichiers .BGI) en plus de votre programme .EXE. De plus, si votre programme utilise des polices de caractères avec traits, vous aurez également besoin d'un ou plusieurs fichiers de polices de caractères (.CHR).

Drivers

Les pilotes graphiques sont fournis pour les adaptateurs graphiques suivants (et les vrais compatibles) :

Chaque pilote contient du code et des données et est entreposé dans un fichier séparé sur le disque. Au moment de l'exécution, la procédure InitGraph identifie le matériel graphique, charge et initialise le pilote graphique approprié, met le système en mode graphique, puis redonne le contrôle à la routine appelante. La procédure CloseGraph décharge le pilote de la mémoire et restaure le mode vidéo précédent. Vous pouvez basculer entre les modes texte et graphique à l'aide des routines RestoreCrtMode et SetGraphMode. Le Graph prend en charge les micro-ordinateurs avec deux moniteurs. Lorsque Graph est initialisé en appelant InitGraph, le moniteur approprié sera sélectionné pour le pilote graphique et le mode demandés. Lors de la fin d'un programme graphique, le mode vidéo précédent sera restauré. Si la détection automatique du matériel graphique est demandée sur un système à double moniteur, InitGraph sélectionnera le moniteur et la carte graphique produisant la sortie graphique de la plus haute qualité.

Pilote Équipement
ATT.BGI AT&T 6300 (400 lignes)
CGA.BGI IBM CGA, MCGA
EGAVGA.BGI IBM EGA, VGA
HERC.BGI Hercules monochrome
IBM8514.BGI IBM 8514
PC3270.BGI IBM 3270 PC

Prise en charge d'IBM 8514

Le Turbo Pascal prend en charge la carte graphique IBM 8514, une carte graphique haute résolution capable de résolutions jusqu'à 1024 x 768 pixels et une palette de couleurs de 256 couleurs parmi une liste de 256K couleurs. Le nom du fichier du pilote est IBM8514.BGI. Le Turbo Pascal ne peut pas correctement détecter automatiquement la carte graphique IBM 8514 (la logique de détection automatique la reconnaît comme VGA). Par conséquent, pour utiliser la carte IBM 8514, la variable GraphDriver doit recevoir la valeur IBM8514 (étant définie dans l'unité Graph) lorsque InitGraph est appelé. Vous ne devez pas utiliser DetectGraph (ou Detect avec InitGraph) avec l'IBM 8514 à moins que vous ne souhaitiez le mode VGA émulé.

Les modes pris en charge de la carte IBM 8514 sont IBM8514LO (640 x 480 pixels) et IBM8514HI (1024 x 768 pixels). Les deux constantes de mode sont définies dans l'interface de GRAPH.TPU ou GRAPH.TPP. L'IBM 8514 utilise trois valeurs 6 bits pour définir les couleurs. Il existe une composante rouge, vert et bleu de 6 bits pour chaque couleur définie. La procédure SetRGBPalette vous permet de définir les couleurs de l'IBM 8514; il est défini dans l'unité Graph comme :

Procedure SetRGBPalette(ColorNum,Red,Green,Blue:Word);

Le paramètre ColorNum définit l'entrée de palette à charger. Le ColorNum est un entier compris entre 0 et 255 (décimal). Les paramètres Red, Green et Blue définissent les couleurs des composants de l'entrée de palette, soit rouge (Red), vert (Green) et bleu (Blue). Seul l'octet inférieur de ces valeurs est utilisé, et sur cet octet, seuls les 6 bits les plus significatifs sont chargés dans la palette. Les autres routines de manipulation de palette de la bibliothèque graphique ne peuvent pas être utilisées avec le pilote IBM 8514 (c'est-à-dire SetAllPalette, SetPalette et GetPalette). Pour la compatibilité avec la balance des adaptateurs graphiques IBM, le pilote BGI définit les 16 premières entrées de palette de l'IBM 8514 avec les couleurs par défaut de l'EGA/VGA. Ces valeurs peuvent être utilisées telles quelles ou modifiées à l'aide de la routine SetRGBPalette.

Système de coordonnées

Par convention, le coin supérieur gauche de l'écran graphique est (0,0). Les valeurs x, ou colonnes, s'incrémentent vers la droite. Les valeurs y, ou lignes, augmentent vers le bas. En mode 320x200 sur une carte vidéo CGA, les coordonnées de l'écran pour chacun des quatre coins avec un point spécifié au milieu de l'écran ressembleraient à ceci :

Pointeur courant

De nombreux systèmes graphiques prennent en charge la notion de pointeur courant (CP). Le CP est similaire dans son concept à un curseur en mode texte, sauf que le CP n'est pas visible. En mode texte, l'instruction Write :

Write('Gladir.com');

laisse le curseur dans la colonne immédiatement après la lettre m. Si le m est écrit dans la colonne 80, le curseur revient à la colonne 1 de la ligne suivante. Si le m est écrit dans la colonne 80 sur la 25e ligne, tout l'écran défile d'une ligne vers le haut et le curseur se trouve dans la colonne 1 de la ligne 25.

MoveTo(0,0);
LineTo(20,20);

En mode graphique, l'instruction LineTo précédente laisse le CP au dernier point référencé (20,20). La sortie de ligne réelle est découpée dans la fenêtre courante si le découpage est actif. Notez que le CP n'est jamais couper. La commande MoveTo est l'équivalent de GoToXY. Son seul but est de déplacer le CP. Seules les commandes utilisant le CP déplacent le CP : InitGraph, MoveTo, MoveRel, LineTo, LineRel, OutText, SetGraphMode, GraphDefaults, ClearDevice, SetViewPort et ClearViewPort. Les cinq dernières commandes déplacent le CP vers (0,0).

Texte

Une police de caractères bitmap 8x8 et plusieurs polices de caractères barrées sont incluses pour la sortie de texte en mode graphique. Un caractère bitmap est défini par une matrice 8x8 de pixels. Une police barrée est définie par une série de vecteurs indiquant au système graphique comment dessiner la police de caractères. L'avantage d'utiliser une police avec traits est évident lorsque vous commencez à dessiner de grands caractères. Étant donné qu'une police de caractères barrée est définie par des vecteurs, elle conserve une bonne résolution et une bonne qualité lorsque la police de caractères est agrandie. Lorsqu'une police de caractères bitmap est agrandie, la matrice est multipliée par un facteur de mise à l'échelle et, à mesure que le facteur de mise à l'échelle devient plus grand, la résolution des caractères devient plus grossière. Pour les petits caractères, la police de caractères bitmap est généralement suffisante, mais pour un texte plus grand, vous voudrez sélectionner une police de caractères barrée. La justification du texte graphique est contrôlée par la procédure SetTextJustify. La mise à l'échelle et la sélection des polices de caractères sont effectuées avec la procédure SetTextstyle. Le texte graphique est généré en appelant les procédures OutText ou OutTextXY. Les demandes de renseignements sur les paramètres de texte actuels sont effectuées en appelant la procédure GetTextsettings. La taille des polices de caractères barrées peut être personnalisée par la procédure SetUserCharsize. Chaque police de caractères barrée est conservée dans son propre fichier sur le disque avec une extension de fichier .CHR. Les fichiers de polices de caractères peuvent être chargés automatiquement à partir du disque par l'unité Graph au moment de l'exécution (comme décrit), ou ils peuvent être liés ou chargés par le programme utilisateur et enregistrés avec l'unité Graph. Le Turbo Pascal fournit un utilitaire spécial, BINOBJ.EXE, convertissant un fichier de police de caractères (ou tout fichier de données binaires, d'ailleurs) en un fichier .OBJ pouvant être lié à une unité ou à un programme en utilisant la directive de compilation {$L}. Il permet à un programme d'avoir tous ses fichiers de polices de caractères intégrés dans le fichier .EXE.

Figures et styles

Toutes sortes de routines de support sont fournies pour dessiner et remplir des figures, y compris des points, des lignes, des cercles, des arcs, des ellipses, des rectangles, des polygones, des barres, des barres 3D et des secteurs. Utilisez SetLinestyle pour contrôler si les lignes sont épaisses ou fines, ou si elles sont pleines, en pointillé ou créées à l'aide de votre propre motif. Utilisez SetFillstyle et SetFillPattern, FillPoly et FloodFill pour remplir une région ou un polygone avec des hachures croisées ou d'autres motifs complexes.

Fenêtres et images bit

La procédure SetViewPort fait fonctionner toutes les commandes de sortie dans une zone rectangulaire à l'écran. Les tracés, les lignes et les figures - toutes les sorties graphiques - sont relatifs à la fenêtre jusqu'à ce que la fenêtre soit modifiée. D'autres routines sont fournies pour effacer une fenêtre et lire les définitions de fenêtre actuelles. Si le découpage est actif, toute la sortie graphique est découpée sur le port actuel. Notez que le CP n'est jamais découper. Les routines GetPixel et PutPixel sont fournis pour la lecture et le traçage des pixels. Les routines GetImage et PutImage peuvent être utilisés pour enregistrer et restaurer des régions rectangulaires à l'écran. Ils prennent en charge le complément complet des opérations BitBlt (copie, XOR, OR, et NOT).

Pagination et couleurs

Il existe de nombreuses autres routines prenant en charge les palettes, les couleurs, plusieurs pages graphiques (EGA, VGA et Hercules uniquement), et bien d'autres.

La gestion des erreurs

Les erreurs internes dans l'unité Graph sont renvoyées par la fonction GraphResult. La fonction GraphResult renvoie un code d'erreur signalant l'état de la dernière opération graphique. Les routines suivantes définissent GraphResult :

La fonction GraphResult est remis à zéro après avoir été appelé. Par conséquent, l'utilisateur doit entreposer la valeur de GraphResult dans une variable temporaire, puis la tester.

Comment commencer

Voici un programme graphique simple :

  1. Program GraphTst;
  2. Uses
  3.  Graph;
  4. Const
  5.  S='Borland Graphics Interface (BGI)';
  6. Var
  7.  GraphDriver,GraphMode,ErrorCode:Integer;
  8.  Size:Word;
  9. BEGIN
  10.  GraphDriver:=Detect; { Fixe le drapeau, faire la détection }
  11.  InitGraph(GraphDriver,GraphMode,'C:\TP\BGI');
  12.  ErrorCode:=GraphResult;
  13.  If ErrorCode <> GrOk Then Begin { Erreur ? }
  14.    WriteLn('Erreur graphique : ',GraphErrorMsg(ErrorCode));
  15.    WriteLn('Programme abandonné...');
  16.    Halt(1);
  17.  End;
  18.  Rectangle(0,0,GetMaxX,GetMaxY);
  19.  SetTextJustify(CenterText, CenterText);
  20.  Size:=3;
  21.  Repeat
  22.   SetTextStyle(DefaultFont,HorizDir,Size);
  23.   Dec(Size);
  24.  Until (Size=0) or (TextWidth(S) < GetMaxX);
  25.  If Size <> 0 Then OutTextXY(GetMaxX div 2, GetMaxY div 2, S);
  26.  ReadLn;
  27.  CloseGraph;
  28. END.

Le programme commence par un appel à InitGraph, détectant automatiquement le matériel et charge le pilote graphique approprié. Pour que le programme s'exécute correctement, le pilote et les polices de caractères doivent être dans le même répertoire que le programme exécutable, ou le programme doit spécifier un répertoire explicite. Dans cet exemple, le répertoire est C:\TP\BGI. Si le programme ne reconnaît pas le matériel graphique ou si une erreur se produit lors de l'initialisation, le programme affiche un message d'erreur et s'arrête. Sinon, le programme dessine une boîte le long du bord de l'écran et affiche du texte au centre de l'écran.

Ni le carte AT&T de 400 lignes ni la carte graphique IBM 8514 ne sont détectés automatiquement. Vous pouvez toujours utiliser ces pilotes en remplaçant la détection automatique et en transmettant à InitGraph le code du pilote et un mode graphique valide. Pour utiliser le pilote AT&T, par exemple, remplacez les neuvième et dixième lignes de l'exemple précédent par les trois lignes de code suivantes :

GraphDriver := ATT400;
GraphMode := ATT400Hi;
InitGraph(GraphDriver,GraphMode,'C:\TP\BGI');

Cette situation demande au système graphique de charger le pilote de ligne AT&T 400 situé dans C:\TP\BGI et de définir le mode graphique sur 640 par 400. Voici un autre exemple montrant comment basculer entre les modes graphique et texte :

  1. Program Graf2Txt;
  2. Uses
  3.  Graph;
  4. Var
  5.  GraphDriver:Integer;
  6.  GraphMode:Integer;
  7.  ErrorCode:Integer;
  8. BEGIN
  9.  GraphDriver:=Detect; { Fixe le drapeau, faire la détection }
  10.  InitGraph(GraphDriver, GraphMode,'C:\TP\BGI');
  11.  ErrorCode:=GraphResult;
  12.  If ErrorCode <> grOk Then Begin
  13.   WriteLn('Erreur graphique : ',GraphErrorMsg(ErrorCode));
  14.   Writeln('Programme abandonné...');
  15.   Halt(1);
  16.  End;
  17.  OutText('En mode graphique. Presse <ENTER>');
  18.  ReadLn;
  19.  RestoreCRTMode;
  20.  Write('Maintenant en mode texte. Presse <ENTER>');
  21.  ReadLn;
  22.  SetGraphMode(GraphMode) ;
  23.  OutText('Retourne en mode graphique. Presse <ENTER>');
  24.  ReadLn;
  25.  CloseGraph;
  26. END.

Notez que l'appel SetGraphMode vers la fin de l'exemple réinitialise tous les paramètres graphiques (palette, pointeur actuel, couleurs de premier plan et d'arrière-plan,...) aux valeurs par défaut. L'appel à CloseGraph restaure le mode vidéo ayant été détecté initialement par InitGraph et libère la mémoire de tas ayant été utilisée pour contenir le pilote graphique.

Routines de gestion de mémoire de tas

Deux routines de gestion de mémoire de tas sont utilisées par l'unité Graph : GraphGetMem et GraphFreeMem. Le GraphGetMem alloue de la mémoire pour les pilotes de périphériques graphiques, les polices de caractères barrées et un tampon de numérisation. Le GraphFreeMem désalloue la mémoire allouée aux pilotes. Les routines standard prennent la format suivante :

{Allouer de la mémoire pour les graphiques}
Procedure GraphGetMem(Var P:Pointer;Size:Word);

{Désallouer la mémoire pour les graphiques}
Procedure GraphFreeMem(var P:Pointer;Size:Word);

Deux pointeurs sont définis par Graph qui, par défaut, pointent vers les deux routines standard décrites ici. Les pointeurs sont définis comme suit :

Var
GraphGetMemPtr:Pointer; { Pointeur vers la routine d'allocation de mémoire }
GraphFreeMemPtr:Pointer; { Pointeur vers la routine d'emplacement de transaction de mémoire }

L'unité Graph appelle les routines de gestion de tas référencées par GraphGetMemPtr et GraphFreeMemPtr pour allouer et désallouer de la mémoire à trois fins différentes :

Le tampon graphique est toujours alloué sur la mémoire de tas. Le pilote de périphérique est alloué sur la mémoire de tas sauf si votre programme en charge ou en lie un et appelle RegisterBGIdriver. Le fichier de police de caractères est alloué sur la mémoire tas lorsque vous sélectionnez une police de caractères barrée à l'aide de SetTextStyle, sauf si votre programme charge ou lie un et appelle RegisterBGIfont. Lorsque l'unité Graph est initialisée, ces pointeurs pointent vers les routines standard d'allocation et de désallocation de graphiques définies dans la section IMPLEMENTATION de l'unité Graph. Vous pouvez insérer vos propres routines de gestion de la mémoire en attribuant à ces pointeurs l'adresse de vos routines. Les routines définies par l'utilisateur doivent avoir les mêmes listes de paramètres que les routines standard et doivent être des procédures éloignées. Voici un exemple de routines d'allocation et de désallocation définies par l'utilisateur; notez l'utilisation de MyExitProc pour appeler automatiquement CloseGraph lorsque le programme se termine :

  1. Program UserHeapManagement;
  2. Uses Graph;
  3. Var
  4.  GraphDriver,GraphMode,ErrorCode:Integer;
  5.  PreGraphExitProc:Pointer;
  6.  
  7. Procedure MyGetMem(Var P:Pointer;Size:Word);Far;Begin
  8.  GetMem(P,Size);
  9. End;
  10.  
  11. Procedure MyFreeMem(Var P:Pointer; Size:Word);Far;Begin
  12.  If P <> NIL Then Begin
  13.   FreeMem(P, Size);
  14.   P := NIL;
  15.  End;
  16. End;
  17.  
  18. Procedure MyExitProc;Far;Begin
  19.  ExitProc := PreGraphExitProc;
  20.  CloseGraph;
  21. End;
  22.  
  23. BEGIN
  24.  PreGraphExitProc := ExitProc;
  25.  ExitProc := @MyExitProc;
  26.  GraphGetMemPtr := @MyGetMem;
  27.  GraphFreeMemPtr := @MyFreeMem;
  28.  GraphDriver := Detect;
  29.  InitGraph(GraphDriver,GraphMode,'');
  30.  ErrorCode := GraphResult;
  31.  If ErrorCode <> grOk Then Begin
  32.   Writeln('Erreur graphique : ', GraphErrorMsg(ErrorCode));
  33.   ReadLn;
  34.   Halt(1);
  35.  End;
  36.  Line(0,0,GetMaxX,GetMaxY);
  37.  OutTextXY(1, 1, 'Presse <ENTER>:');
  38.  ReadLn;
  39. END.

Procédures et fonctions graphiques

L'unité Graph fournit de nombreuses procédures et fonctions à utiliser dans vos programmes :

Nom Description
Arc Dessine un arc circulaire de l'angle de départ à l'angle de fin en utilisant (x,y) comme point central.
Bar Dessine une barre en utilisant le style et la couleur de remplissage actuels.
Bar3D Dessine une barre 3D en utilisant le style et la couleur de remplissage actuels.
Circle Dessine un cercle en utilisant (x, y) comme point central.
ClearDevice Efface le périphérique de sortie actuellement sélectionné et place le pointeur courant.
ClearViewPort Efface la fenêtre courante.
CloseGraph Arrête le système graphique.
DetectGraph Vérifie le matériel et détermine le pilote graphique et le mode à utiliser.
DrawPoly Dessine le contour d'un polygone en utilisant le style et la couleur de ligne courante.
Ellipse Dessine un arc elliptique de l'angle de départ à l'angle de fin, en utilisant (x, y) comme point central.
FillEllipse Dessine une ellipse pleine en utilisant (x, y) comme point central et XRadius et YRadius comme axes horizontal et vertical.
FillPoly Remplit un polygone à l'aide du convertisseur de balayage.
FloodFill Remplit une région délimitée en utilisant le motif de remplissage et la couleur de remplissage actuels.
GetArcCoords Permet à l'utilisateur de se renseigner sur les coordonnées de la dernière commande Arc.
GetAspectRatio Renvoie la résolution effective de l'écran graphique à partir de laquelle le rapport hauteur/largeur (Xasp:Yasp) peut être calculé.
GetBkColor Renvoie la couleur d'arrière-plan actuelle.
GetColor Renvoie la couleur de dessin actuelle.
GetDefaultPalette Renvoie la palette matérielle par défaut dans un enregistrement de PaletteType.
GetDriverName Renvoie une chaîne contenant le nom du pilote actuel.
GetFillPattern Renvoie le dernier motif de remplissage défini par un appel à SetFillPattern.
GetFillSettings Permet à l'utilisateur de se renseigner sur le motif et la couleur de remplissage actuels définis par SetFillStyle ou SetFillPattern.
GetGraphMode Renvoie le mode graphique actuel.
GetImage Enregistre une image binaire de la région spécifiée dans un tampon.
GetLineSettings Renvoie le style de ligne, le motif de ligne et l'épaisseur de ligne actuels tels que définis par SetLineStyle.
GetMaxColor Renvoie la couleur la plus élevée pouvant être transmise à SetColor.
GetMaxMode Renvoie le numéro de mode maximum pour le pilote actuellement chargé.
GetMaxX Renvoie la colonne la plus à droite (résolution x) du pilote graphique et du mode actuels.
GetMaxY Renvoie la ligne la plus basse (résolution y) du pilote graphique et du mode actuels.
GetModeName Renvoie une chaîne contenant le nom du mode graphique spécifié.
GetModeRange Renvoie le mode graphique valide le plus bas et le plus élevé pour un pilote donné.
GetPaletteSize Renvoie la taille de la table de recherche des couleurs de la palette.
GetPixel Obtient la valeur de pixel à (x, y).
GetPalette Renvoie la palette actuelle et sa taille.
GetTextSettings Renvoie la police, la direction, la taille et la justification du texte actuelles telles que définies par SetTextStyle et SetTextJustify.
GetViewSettings Permet à l'utilisateur de se renseigner sur la fenêtre actuelle et les paramètres de découpage.
GetX Renvoie la coordonnée x de la position actuelle (CP).
GetY Renvoie la coordonnée y de la position actuelle (CP).
GraphDefaults Abrite le pointeur actuel (CP) et réinitialise le système graphique.
GraphErrorMsg Renvoie une chaîne de caractères de message d'erreur pour le ErrorCode spécifié.
GraphResult Renvoie un code d'erreur pour la dernière opération graphique.
ImageSize Renvoie le nombre d'octets requis pour entreposer une région rectangulaire de l'écran.
InstallUserDriver Installe un pilote de périphérique ajouté par le fournisseur dans la table des pilotes de périphérique BGI.
InstallUserFont Installe un nouveau fichier de police qui n'est pas intégré au système BGI.
InitGraph Initialise le système graphique et met le matériel en mode graphique.
Line Trace une ligne entre (x1,y1) et (x2,y2).
LineRel Dessine une ligne vers un point situé à une distance relative du pointeur actuel (CP).
LineTo Dessine une ligne du pointeur actuel vers (x, y).
MoveRel Déplace le pointeur actuel (CP) d'une distance relative par rapport à sa position actuelle.
MoveTo Déplace le pointeur graphique actuel (CP) vers (x, y).
OutText Envoie une chaîne au périphérique de sortie au niveau du pointeur actuel.
OutTextXY Envoie une chaîne au périphérique de sortie.
PieSlice Dessine et remplit une tranche à secteurs, en utilisant (x, y) comme point central et en dessinant de l'angle de départ à l'angle de fin.
PutImage Met une petite image sur l'écran.
PutPixel Trace un pixel en (x, y).
Rectangle Dessine un rectangle en utilisant le style et la couleur de ligne actuels.
RegisterBGIdriver Enregistre un pilote BGI valide avec le système graphique.
RegisterBGIfont Enregistre une police BGI valide avec le système graphique.
RestoreCrtMode Restaure le mode d'écran d'origine avant l'initialisation des graphiques.
Sector Dessine et remplit un secteur elliptique.
SetActivePage Définit la page active pour la sortie graphique.
SetAllPalette Modifie toutes les couleurs de la palette comme spécifié.
SetAspectRatio Modifie le rapport de ratio de hauteur et de largeur par défaut.
SetBkColor Définit la couleur d'arrière-plan actuelle à l'aide de la palette.
SetColor Définit la couleur de dessin actuelle à l'aide de la palette.
SetFillPattern Sélectionne un motif de remplissage défini par l'utilisateur.
SetFillStyle Définit le motif et la couleur de remplissage.
SetGraphBufSize Permet de modifier la taille du tampon utilisé pour les remplissages d'analyse et d'inondation.
SetGraphMode Règle le système en mode graphique et efface l'écran.
SetLineStyle Définit la largeur et le style de ligne actuels.
SetPalette Modifie une couleur de palette comme spécifié par ColorNum et Color.
SetRGBPalette Permet de modifier les entrées de palette pour les pilotes IBM 8514 et VGA.
SetTextJustify Définit les valeurs de justification du texte utilisées par OutText et OutTextXY.
SetTextStyle Définit la police de caractères, le style et le facteur d'agrandissement des caractères actuels.
SetUserCharSize Vous permet de modifier la largeur et la hauteur des caractères pour les polices de caractères à traits.
SetViewPort Définit la fenêtre ou la fenêtre de sortie actuelle pour la sortie graphique.
SetVisualPage Définit le numéro de page des graphiques visuels.
SetWriteMode Définit le mode d'écriture (copie ou XOR) pour les lignes dessinées par DrawPoly, Line, LineRel, LineTo et Rectangle.
TextHeight Renvoie la hauteur d'une chaîne de caractères en pixels.
TextWidth Renvoie la largeur d'une chaîne de caractères en pixels.

Constantes, types et variables d'unité graphique

L'unité Graph définit plusieurs constantes, types et variables que vos programmes peuvent utiliser.

Constantes

Les constantes Graph peuvent être regroupées par leur fonction. Recherchez la constante sous le groupe auquel elle appartient. Ce tableau vous aidera à identifier le groupe que vous souhaitez :

Groupe de constante Description
Pilote et mode Constantes spécifiant les pilotes et les modes vidéo; utilisé avec InitGraph, DetectGraph et GetModeRange.
grXXXX Constantes identifiant le type d'erreur renvoyé par GraphResult.
Couleur Constantes spécifiant les couleurs; utilisé avec SetPalette et SetAllPalette.
Couleur pour SetRGBPalette Constantes utilisées avec SetRGBPalette pour sélectionner les couleurs EGA standard sur un IBM 8514.
Style de ligne Constantes utilisées pour déterminer un style et une épaisseur de ligne; utilisé avec GetLineSettings et SetLinestyle.
Contrôle des polices de caractères Constantes identifiant les polices de caractères; utilisé avec GetTextSettings et SetTextStyle.
Justification Constantes contrôlant la justification horizontale et verticale; utilisé avec SetTextJustify.
Coupure Constantes contrôlant les coupures; utilisé avec SetViewPort.
Bar Constantes contrôlant le dessin d'un dessus en 3 dimensions sur une barre; utilisé avec Bar3D.
Motif de remplissage Constantes déterminant le motif utilisé pour remplir une zone; utilisé avec GetFillSettings et SetFillStyle.
Opérateurs BitBlt Opérateurs (copie, XOR, OR, AND, et NOT) utilisés avec PutImage et SetWriteMode.
MaxColors Constante définissant le nombre maximal de couleurs utilisées avec GetPalette, GetDefaultPalette et SetAllPalette.

Types

L'unité Graph définit ces types :

Type Description
PaletteType L'enregistrement définissant la taille et les couleurs de la palette; utilisé par GetPalette, GetDefaultPalette et SetAllPalette.
LineSettingsType L'enregistrement définissant le style, le motif et l'épaisseur d'une ligne; utilisé par GetLineSettings.
TextSettingsType L'enregistrement définissant le texte; utilisé par GetTextSettings.
FillSettingsType L'enregistrement définissant le motif et la couleur utilisés pour remplir une zone; utilisé par GetFillSettings.
FillPatternType L'enregistrement définissant un motif de remplissage défini par l'utilisateur; utilisé par GetFillPattern et SetFillPattern.
PointType Un type de point défini pour votre commodité.
ViewPortType Un enregistrement rapportant l'état de la fenêtre courante; utilisé par GetViewSettings.
ArcCoordsType Un enregistrement récupérant des informations sur le dernier appel à Arc ou Ellipse; utilisé par GetArcCoords.

Variables

L'unité Graph a deux variables que vous pouvez utiliser : GraphGetMemPtr et GraphFreeMemPtr. Ils sont utilisés par les routines de gestion de mémoire de tas.



Dernière mise à jour : Dimanche, le 15 novembre 2020