Section courante

A propos

Section administrative du site

Les fondements de WinGraph

Cette section contient les explications sur les routines et les types de données proposés par WinGraph.

Aperçu des routines

Légende :

Routines d'initialisation

Routines de gestion d'écran

Routines de gestion des couleurs

Routines de dessin de primitives

Routines de dessins remplis

Routines de gestion du texte et des polices de caractères

Routines de gestion du clavier (nécessite WinCrt)

Routines de gestion de la souris (nécessite WinMouse)

Aperçu des types

  1. Type
  2.  AnimatType=Record
  3.   bitHnd,maskHnd,bkgHnd:LongWord;
  4.  End;
  5.  
  6.  ArcCoordsType=Record
  7.   x,y,xstart,ystart,xend,yend:SmallInt;
  8.  End;
  9.  
  10.  FillSettingsType=Record
  11.   Pattern:Word;
  12.   Color:LongWord;
  13.  End;
  14.  
  15.  FillPatternType=Array [1..8] of Byte;
  16.  
  17.  LineSettingsType=Record
  18.   LineStyle,Pattern,Thickness:Word;
  19.  End;
  20.  
  21.  PaletteType=Record
  22.   Size:Word;
  23.   Colors:Array[0..255] of LongWord;
  24.  End;
  25.  
  26.  PointType=Record
  27.   x,y:LongInt;
  28.  End;
  29.  
  30.  TextSettingsType=Record
  31.   Font,Direction,CharSize,Horiz,Vert:Word;
  32.  End;
  33.  
  34.  ViewPortType=Record
  35.   x1,y1,x2,y2:SmallInt;
  36.   Clip:Boolean;
  37.  End;
  38.  
  39.  MouseEventType=Record
  40.   Action:Word;
  41.   Buttons:Word;
  42.   x,y:Word;
  43.   Wheel:SmallInt;
  44.  End;

Aperçu des variables et des constantes

Version de Wingraph (chaîne de caractères)

  1. WinGraphVer

Codes d'erreur (SmallInt)

  1. grOk,grNoInitGraph,grInvalidDriver,grInvalidMode,grNotWindow,grInvalidFont, grInvalidFontNum,grInvalidParam,grNoPalette,grNoOpenGL,grError

Pilotes graphiques (SmallInt)

  1. D1bit,D4bit,D8bit,Detect,NoPalette,HercMono,VGA,SVGA

Modes graphiques (SmallInt)

  1. m320x200,m640x200,m640x350,m640x480,m720x350,m800x600,m1024x768,m1280x1024, mDefault,mMaximized,mFullScr,mCustom,HercMonoHi,VGALo,VGAMed,VGAHi

Mettre à jour les constantes graphiques (Word)

  1. UpdateOff,UpdateOn,UpdateNow

Modes de dessin OpenGL (Boolean)

  1. DirectOn,DirectOff

Constantes de découpage (Boolean)

  1. ClipOn,ClipOff

Constantes d'opération raster (Word)

  1. CopyPut,XorPut,OrPut,AndPut,NotPut,NotOrPut,InvBitOrPut,InvScrAndPut,NormalPut,TransPut,MaskPut,BkgPut

Modes de dessin à l'écran (SmallInt)

  1. CopyMode,XorMode,OrMode,AndMode,NotMode,NotScrMode,NotXorMode,NotOrMode, NotAndMode,InvColAndMode,InvColOrMode,InvScrAndMode,InvScrOrMode,BlackMode, WhiteMode,EmptyMode,Transparent,Opaque

Noms de couleurs alphabétiques (LongWord)

  1. AliceBlue,AlizarinCrimson,Amber,Amethyst,AntiqueWhite,Aquamarine,Asparagus,
  2. Azure,Beige,Bisque,Bistre,BitterLemon,Black,BlanchedAlmond,BlazeOrange,Blue,
  3. BlueViolet,BondiBlue,Brass,BrightGreen,BrightTurquoise,BrightViolet,Bronze,
  4. Brown,Buff,Burgundy,BurlyWood,BurntOrange,BurntSienna,BurntUmber,CadetBlue,
  5. CamouflageGreen,Cardinal,Carmine,Carrot,Casper,Celadon,Cerise,Cerulean,
  6. CeruleanBlue,Chartreuse,Chocolate,Cinnamon,Cobalt,Copper,Coral,Corn,
  7. CornflowerBlue,Cornsilk,Cream,Crimson,Cyan,DarkBlue,DarkBrown,DarkCerulean,
  8. DarkChestnut,DarkCoral,DarkCyan,DarkGoldenrod,DarkGray,DarkGreen,DarkIndigo,
  9. DarkKhaki,DarkMagenta,DarkOlive,DarkOliveGreen,DarkOrange,DarkOrchid,
  10. DarkPastelGreen,DarkPink,DarkRed,DarkSalmon,DarkScarlet,DarkSeaGreen,
  11. DarkSlateBlue,DarkSlateGray,DarkSpringGreen,DarkTan,DarkTangerine,
  12. DarkTeaGreen,DarkTerraCotta,DarkTurquoise,DarkViolet,DeepPink,DeepSkyBlue,
  13. Denim,DimGray,DodgerBlue,Emerald,Eggplant,FernGreen,FireBrick,Flax,
  14. FloralWhite,ForestGreen,Fractal,Fuchsia,Gainsboro,Gamboge,GhostWhite,Gold,
  15. Goldenrod,Gray,GrayAsparagus,GrayTeaGreen,Green,GreenYellow,Heliotrope,
  16. Honeydew,HotPink,IndianRed,Indigo,InternationalKleinBlue,InternationalOrange,
  17. Ivory,Jade,Khaki,Lavender,LavenderBlush,LawnGreen,Lemon,LemonChiffon,
  18. LightBlue,LightBrown,LightCoral,LightCyan,LightGoldenrodYellow,LightGray,
  19. LightGreen,LightMagenta,LightPink,LightRed,LightSalmon,LightSeaGreen,
  20. LightSkyBlue,LightSlateGray,LightSteelBlue,LightYellow,Lilac,Lime,LimeGreen,
  21. Linen,Magenta,Malachite,Maroon,Mauve,MediumAquamarine,MediumBlue,
  22. MediumOrchid,MediumPurple,MediumSeaGreen,MediumSlateBlue,MediumSpringGreen,
  23. MediumTurquoise,MediumVioletRed,MidnightBlue,MintCream,MistyRose,Moccasin,
  24. MoneyGreen,Monza,MossGreen,MountbattenPink,Mustard,NavajoWhite,Navy,Ochre,
  25. OldGold,OldLace,Olive,OliveDrab,Orange,OrangeRed,Orchid,PaleBrown,
  26. PaleCarmine,PaleChestnut,PaleCornflowerBlue,PaleGoldenrod,PaleGreen,
  27. PaleMagenta,PaleMauve,PalePink,PaleSandyBrown,PaleTurquoise,PaleVioletRed,
  28. PapayaWhip,PastelGreen,PastelPink,Peach,PeachOrange,PeachPuff,PeachYellow,
  29. Pear,Periwinkle,PersianBlue,Peru,PineGreen,Pink,PinkOrange,Plum,PowderBlue,
  30. PrussianBlue,Puce,Pumpkin,Purple,RawUmber,Red,Reef,RobinEggBlue,RosyBrown,
  31. RoyalBlue,Russet,Rust,SaddleBrown,Saffron,Salmon,SandyBrown,Sangria,Sapphire,
  32. Scarlet,SchoolBusYellow,SeaGreen,SeaShell,SelectiveYellow,Sepia,Sienna,
  33. Silver,SkyBlue,SlateBlue,SlateGray,Snow,SpringGreen,SteelBlue,SwampGreen,
  34. Taupe,Tangerine,Teal,TeaGreen,Tenne,TerraCotta,Thistle,Tomato,Turquoise,
  35. Ultramarine,Vermilion,Violet,VioletEggplant,Viridian,Wheat,White,WhiteSmoke,
  36. Wisteria,Yellow,YellowGreen,Zinnwaldite

Style de dessin pour les lignes (Word)

  1. SolidLn,DottedLn,DashDotLn,DashedLn,DashDotDotLn,UserBitLn,NullLn

Constantes d'épaisseurs pour les lignes (Word)

  1. NormWidth,DoubleWidth,TripleWidth,QuadWidth,ThickWidth

Motifs de remplissage (Word)

  1. EmptyFill,SolidFill,LineFill,ColFill,HatchFill,SlashFill,BkSlashFill,XHatchFill,UserFill,NoFill

Constantes Bar3D (Boolean)

  1. TopOn,TopOff

Constantes du mode d'inondation (SmallInt)

  1. BorderFlood,SurfaceFlood

Justifier les constantes pour le texte (Word)

  1. LeftText,CenterText,RightText,TopText,BottomText,BaselineText

Constantes de direction pour le texte (Word)

  1. HorizDir,VertDir

Constantes de police de caractères pour le texte (mot)

  1. CourierNewFont,MSSansSerifFont,TimesNewRomanFont,ArialFont,DefaultFont

Plus de constantes de police pour le texte (mot)

  1. ItalicFont,UnderlineFont,BoldFont

Format caret : bloc ou souligné (Boolean)

  1. CaretBlock

Cadence de clignotement du caret en dixièmes de seconde (mot)

  1. BlinkRate

Constantes de la souris (Word)

  1. MouseActionDown,MouseActionUp,MouseActionMove,MouseActionWheel,
  2. MouseLeftButton,MouseRightButton,MouseMiddleButton,MouseShiftKey,
  3. MouseCtrlKey

Routines WinGraph

WinGraph est l'unité principale utilisée pour effectuer des graphiques dans une fenêtre graphique à l'aide d'un ensemble de routines similaires à celles de l'unité Graph de Borland Pascal (BP).

Procedure Arc(x,y:SmallInt;Start,Stop,Radius:Word);

Cette procédure permet de dessiner une partie d'un cercle avec le centre à (x,y), le rayon (radius), en partant de l'angle (start), en s'arrêtant à l'angle (stop). Ces angles sont mesurés dans le sens antihoraire. Il utilise la couleur de premier plan actuelle. Pour dessiner un cercle entier, utilisez Circle.

Procedure Bar(x1,y1,x2,y2:SmallInt);

Cette procédure permet de dessiner et de remplir un rectangle avec des coins opposés à (x1,y1) et (x2,y2), en utilisant le style et la couleur de remplissage actuels. Ce rectangle n'a pas de bordure. Utilisez FillRect pour dessiner un rectangle rempli avec une bordure.

Procedure Bar3D(x1,y1,x2,y2:SmallInt;Depth:Word;Top:Boolean);

Cette procédure permet de tracer une rectangle avec un effet de profondeur en 3 dimensions dans un écran graphique.

Dessine et remplit une barre tridimensionnelle avec les coins opposés de la facette avant à (x1,y1) et (x2,y2). Il utilise la couleur de premier plan actuelle. Seule la facette avant est remplie avec le style et la couleur de remplissage actuels. Le paramètre (Depth) spécifie le nombre de pixels utilisés pour afficher la profondeur de la barre. Si (top) est True, alors un top tridimensionnel est dessiné. Ses valeurs prédéfinies sont :

Constante Description
TopOn=True Haut tri-dimensionnel
TopOff=False Haut bi-dimensionnel

Utilisez Bar pour dessiner une barre à 2 dimensions.

Procedure Chord(x,y:SmallInt;Start,Stop,XRadius,YRadius:Word);

Cette procédure permet de dessiner et de remplir une corde (une région délimitée par l'intersection d'une ellipse et d'un segment de droite - appelée sécante). Il utilise la couleur de premier plan et le style de remplissage actuels. Les paramètres ont la même signification que dans Ellipse. Pour dessiner un secteur d'ellipse, utilisez Sector.

Procedure Circle(x,y:SmallInt;Radius:Word);

Cette procédure permet de dessiner un cercle complet avec le centre à (x,y) et le rayon (radius). Pour dessiner une partie d'un cercle, utilisez Arc.

Procedure ClearDevice;

Cette procédure efface tout l'écran graphique à l'aide de la routine ClearViewPort. Le pointeur actuel est réinitialisé à (0,0), c'est-à-dire dans le coin supérieur gauche de l'écran.

Procedure ClearViewPort;

Cette procédure permet d'effacer la fenêtre courante. La couleur de fond actuelle est utilisée comme couleur de remplissage. Le pointeur est défini sur (0,0), c'est-à-dire le coin supérieur gauche de la fenêtre.

Procedure CloseGraph;

Cette procédure permet de fermer la fenêtre graphique et libère toutes les ressources lui étant liées. La fenêtre de la console parente s'affiche à nouveau au premier plan (le cas échéant). Vous pouvez restaurer la fenêtre graphique à l'aide de SetGraphMode ou InitGraph.

Function CloseGraphRequest:Boolean;

Cette fonction permet de vérifier si l'utilisateur a cliqué sur le bouton de fermeture de la fenêtre graphique avec la souris. C'est au programmeur de gérer cette requête. Habituellement, la routine CloseGraph doit être appelée. Si la fenêtre n'a pas de barre de titre, un tel événement ne peut pas être enregistré. Si l'unité WinCrt est incluse, une séquence de touches #0#107 (Alt+F4) est également générée.

Procedure DetectGraph(Out Driver,mode:SmallInt);

Cette procédure permet de retourner les valeurs par défaut pour le pilote graphique (driver) et le mode (mode). Ces valeurs sont égales à driver=NoPalette et mode=mDefault. C'est-à-dire une fenêtre avec toutes les couleurs disponibles et avec une taille par défaut. Voir InitGraph pour une liste des pilotes et des modes.

Procedure DrawBezier(nrpoints:Word;Var Polypoints);

Cette procédure permet de dessiner une ou plusieurs courbes de Bézier cubiques, en utilisant la couleur de premier plan actuelle. Une courbe de Bézier est définie par deux extrémités et deux points de contrôle intermédiaires. Un nombre de 3N+1 sommets définira exactement N courbes de Bézier. Les paramètres sont les mêmes que dans DrawPoly. Il peut être utilisé pour dessiner des courbes irrégulières, mais un cas particulier est une ellipse tournée.

Procedure DrawPoly(nrpoints:Word;Var Polypoints);

Cette procédure permet de dessiner un polygone avec (nrpoints) points d'angle, en utilisant la couleur de premier plan et le style de ligne actuels. Le paramètre (polypoints) doit être un tableau de type PointType contenant au moins (nrpoints) enregistrements. Aucune vérification n'est effectuée. Le dernier point d'angle n'est pas dessiné. Cette procédure est généralement plus rapide que d'utiliser plusieurs appels LineTo.

Procedure Ellipse(x,y:Smallint;Start,Stop,XRadius,YRadius:Word);

Cette procédure permet de dessiner une partie d'une ellipse dont le centre est à (x,y). Les paramètres (xradius) et (yradius) sont les rayons horizontal et vertical de l'ellipse, (start) et (stop) sont les angles de départ et d'arrêt de l'arc de l'ellipse. Ils sont mesurés dans le sens antihoraire à partir de l'axe des x (3 heures est égal à 0 degré). Il utilise la couleur de premier plan actuelle. Pour dessiner une partie d'un cercle, utilisez Arc. Pour dessiner une ellipse tournée, utilisez RotEllipse.

Procedure FillEllipse(x,y:SmallInt;XRadius,YRadius:Word);

Cette procédure permet de dessiner et de remplir une ellipse entière avec le centre à (x,y). Les paramètres (xradius) et (yradius) sont les rayons horizontal et vertical de l'ellipse. Il utilise la couleur de premier plan et le style de remplissage actuels. Pour dessiner un secteur d'ellipse, utilisez Sector.

Procedure FillPoly(nrpoints:Word;Var Polypoints);

Cette procédure permet de dessiner et de remplir un polygone en utilisant la couleur de premier plan, le style de ligne et le style de remplissage actuels. Les paramètres sont les mêmes que dans DrawPoly. Le polygone est fermé automatiquement en traçant une ligne du dernier sommet au premier.

Procedure FillRect(x1,y1,x2,y2:SmallInt);

Cette procédure permet de dessiner et de remplir un rectangle en utilisant la couleur de premier plan, le style de ligne et de remplissage actuels. Les paramètres sont les mêmes que dans Rectangle. Pour dessiner un rectangle sans bordure, utilisez Bar à la place.

Procedure FloodFill(x,y:SmallInt;Color:LongWord);

Cette procédure permet de remplir une région entourant le point (x,y) jusqu'à ce qu'une condition de couleur soit remplie. Cette condition dépend de (couleur) et du mode d'inondation. Ce mode est défini avec la routine SetFloodMode.

Il y a plusieurs raisons pour lesquelles cette routine peut échouer :

Voir SetFloodMode pour plus de détails.

Procedure FreeAnim(Var anim:AnimatType);

Cette procédure permet de libérer les ressources d'animation associées au descripteur d'animation (anim).

Procedure GetAnim(x1,y1,x2,y2:SmallInt;Color:LongWord;Out anim:AnimatType);

Cette procédure permet d'indiquer une structure d'animation contenant un bitmap, son masque et une image de fond. Avec une telle structure, vous pouvez créer des bitmaps et des animations transparentes, mais vous n'avez aucun accès par programmation à cette structure. GetAnim retourne dans la variable (anim) le descripteur d'une animation avec une image bitmap tirée de l'écran dans le rectangle défini par les coordonnées (x1,y1,x2,y2). Une image de masque est également créée et de la place pour l'image d'arrière-plan est réservée. Le système entrepose lui-même toutes les ressources d'animation en mémoire. Utilisez FreeAnim pour libérer la mémoire après utilisation. La (color) est la couleur transparente à définir. Cette couleur est transformée en noir dans l'image bitmap et associée à la couleur de l'écran. Utilisez PutAnim pour replacer l'animation à l'écran.

Procedure GetArcCoords(Out arccoords:ArcCoordsType);

Cette procédure permet de retourner les coordonnées du dernier appel Arc, Circle ou Ellipse. La structure (arccoords) contient les coordonnées du centre conique, les coordonnées de l'arc de début et de fin.

Procedure GetAspectRatio(Out xasp,yasp:Word);

Cette procédure permet de retourner le rapport d'aspect de l'écran tel qu'il est donné par xasp/yasp. Pour définir un nouveau format d'image, utilisez SetAspectRatio.

Function GetBkColor:LongWord;

Cette fonction permet de retourner la couleur d'arrière-plan actuelle. Il s'agit d'une entrée de palette pour les pilotes basés sur une palette et d'une couleur RVB absolue pour un pilote sans palette. Utilisez SetBkColor pour définir une nouvelle couleur.

Function GetColor:LongWord;

Cette fonction permet de retourner la couleur de dessin actuelle. Il s'agit d'une entrée de palette pour les pilotes basés sur une palette et d'une couleur RVB absolue pour un pilote sans palette. Utilisez SetColor pour définir une nouvelle couleur.

Procedure GetDefaultPalette(Out Palette:PaletteType);

Cette procédure permet de retourner la palette VGA par défaut avec un maximum de 256 couleurs. Par défaut, dans les pilotes basés sur palette, tous les noms de couleur sont cartographiés aux entrées de cette palette. De cette manière, vous obtenez la même composition pour chacune des 16 couleurs de base que dans l'unité Graph de Borland Pascal. Pour récupérer la composition standard (réelle) pour chaque nom de couleur, vous devez utiliser GetNamesPalette.

Function GetDriverName:ShortString;

Cette fonction permet de retourner le nom du pilote graphique sélectionné (et le nombre de couleurs disponibles). Voir InitGraph pour une liste des pilotes graphiques.

Procedure GetFillPattern(Out FillPattern:FillPatternType);

Cette procédure permet de retourner dans (FillPattern) le tableau de remplissage courant. Cela a été défini à l'aide de la routine SetFillPattern.

Procedure GetFillSettings(Out fillinfo:FillSettingsType);

Cette procédure permet de retourner les paramètres de remplissage actuels dans (FillInfo). Cette structure contient le motif et la couleur de remplissage, tels que définis par la routine SetFillStyle.

Procedure GetFontSettings(Out FontName:ShortString;Out Width,Height:Word;Out TTFont:Boolean);

Cette procédure permet de récupérer des informations sur la police de caractères actuellement sélectionnée. Le premier paramètre contient le nom complet enregistré de la police de caractères (exemple 'Courier New'). C'est le même nom utilisé par la routine InstallUserFont lors de l'installation de la police de caractères. Les variables (width) et (height) contiennent les dimensions maximales des caractères de la police de caractères. Si vous souhaitez récupérer les dimensions de caractères spécifiques, utilisez les routines TextWidth et TextHeight. Le paramètre booléen (ttfont) précise si la technologie de cette police de caractères est un TrueType. Si tel est le cas, le texte peut être pivoté à l'écran à l'aide de la routine SetTextStyle. Sinon, il ne peut pas être tourné.

Function GetGraphMode:SmallInt;

Cette fonction permet de retourner le mode graphique actuel (ou le dernier utilisé).

Procedure GetImage(x1,y1,x2,y2:SmallInt;Out Bitmap);

Cette procédure permet de placer une copie de la zone d'écran donnée par rectangle avec les coordonnées (x1,y1,x2,y2) dans la variable (bitmap). Cette variable doit avoir suffisamment de place pour accueillir l'image (utilisez ImageSize pour obtenir la taille exacte). Ensuite, l'image peut être remise à l'écran à l'aide de PutImage. Le format du bitmap est codé en dur à 24 bits par pixel, il est donc indépendant du pilote. En fait (bitmap) contiendra la structure complète d'une image BMP et pourra être sauvegardée sur disque et chargée dans votre visionneuse d'images préférée.

Procedure GetLineSettings(Out LineInfo:LineSettingsType);

Cette procédure permet de retourner les paramètres de ligne actuels dans (lineinfo). C'est-à-dire le style de ligne, le motif et l'épaisseur, tels que définis par SetLineStyle.

Procedure GetNamesPalette(Out Palette:PaletteType);

Cette procédure permet de retourner la palette ayant des entrées les noms de couleur. Il entrepose la composition standard pour tous les noms de couleurs définis par WinGraph. Dans le pilote sans palette, les noms de couleur sont cartographiés aux entrées de cette palette. Ce n'est pas la palette par défaut. La première entrée de couleur dans cette palette n'est pas le noir. Il y a un total de 256 noms de couleurs prédéfinis. Si vous pensez que cela est inutile pour vous, ou si vous souhaitez récupérer les valeurs héritées de 16 noms de couleurs comme dans Borland Pascal, veuillez recompiler la source avec les 256_COLOR_NAMES conditionnels désactivés.

Function GetMaxColor:LongWord;

Cette fonction permet de retourner la couleur la plus élevée pouvant être définie avec SetColor ou d'autres routines acceptant les couleurs. Selon la palette, cette couleur n'est pas toujours blanche. Toutes les couleurs entre 0 et GetMaxColor sont garanties valides. Dans les pilotes basés sur palette, cette fonction est égale à GetPaletteSize -1, sinon elle est égale à $FFFFFF.

Function GetMaxMode:SmallInt;

Cette fonction permet de retourner le numéro de mode valide maximal. C'est toujours mFullScr. Si vous souhaitez récupérer les dimensions de l'écran de l'utilisateur (dimensions du bureau), appelez GetModeRange.

Function GetMaxX:SmallInt;

Cette fonction permet de retourner la coordonnée x maximale (horizontale) en pixels. Cela équivaut à la largeur de la zone client moins 1. Le maximum est placé sur le côté droit.

Function GetMaxY:SmallInt;

Cette fonction permet de retourner la coordonnée y maximale (verticale) en pixels. Cela équivaut à la hauteur de la zone client moins 1. Le maximum est placé en bas.

Function GetModeName(Mode:SmallInt):ShortString;

Cette fonction permet de retourner le nom du mode graphique spécifié (mode).

Procedure GetModeRange(Driver:SmallInt;Out Width,Height:SmallInt);

Cette procédure, contrairement à Borland Pascal, renvoie la largeur et la hauteur, en pixels, de l'écran de l'utilisateur (bureau). Autrement dit, (width) contient la largeur et (height) contient la hauteur. Ils ne dépendent pas du (pilote), étant un paramètre factice. En utilisant cette routine, vous pouvez en savoir plus sur les dimensions de l'écran utilisateur avant d'appeler InitGraph.

Procedure GetPalette(Out Palette:PaletteType);

Cette procédure permet de retourner dans (Palette) la palette courante. Pour récupérer uniquement la taille de la palette, utilisez GetPaletteSize.

Function GetPaletteSize:SmallInt;

Cette fonction permet de retourner le nombre maximal d'entrées dans la palette actuelle. Pour récupérer toute la structure du palais, utilisez GetPalette.

Function GetPixel(x,Y:SmallInt):LongWord;

Cette fonction permet de demander la couleur de pixel du point à la position (x,y). Il s'agit d'une entrée de palette pour les pilotes basés sur une palette et d'une couleur RVB absolue pour un pilote sans palette. Pour définir une nouvelle couleur pour le pixel, utilisez PutPixel.

Function GetRGBColor(r,g,B:Word):LongWord;

Cette fonction, pour le pilote sans palette, il renvoie une valeur de couleur RVB absolue. Dans les pilotes basés sur palette, il renvoie la couleur (index de palette) la plus proche de la composition RVB spécifiée. Voir Routine SetRGBPalette pour une description des paramètres d'entrée. Vous pouvez l'utiliser avant InitGraph pour créer des entrées de couleurs vraies dans une palette. Utilisez GetRGBComponents pour convertir une couleur RVB absolue en ses composantes d'intensité RVB.

Procedure GetRGBComponents(Color:LongWord;Out r,g,b:Word);

Cette procédure permet de retourner les composantes d'intensité (Rouge, Vert, Bleu) de la couleur (color) dans les variables (r), (g), (b). Leurs valeurs sont comprises entre 0 et 255. Par exemple, Black renvoie (0,0,0). Voir aussi GetRGBColor. Le paramètre (couleur) est un index de palette dans les pilotes basés sur palette et une véritable couleur RVB pour le pilote sans palette.

Procedure GetSystemPalette(Out Palette:PaletteType);

Cette procédure permet de retourner un maximum de 256 couleurs à partir de la palette système Windows. Il s'agit de la palette initialisée par le système d'exploitation au démarrage. Vous n'avez aucune garantie que cette palette est la même sur tous les systèmes. En fait, ce n'est pas le cas.

Procedure GetTextSettings(Out TextInfo:TextSettingsType);

Cette procédure permet de retourner les paramètres de police de caractères et de texte actuels dans le paramètre (textinfo). Celui-ci contient le type de police de caractères, la direction, le grossissement, l'alignement horizontal et vertical, tels que définis par les routines SetTextStyle et SetTextJustify.

Procedure GetViewSettings(Out ViewPort:ViewPortType);

Cette procédure permet de retourner la fenêtre d'affichage actuelle et les paramètres de découpage dans (fenêtre d'affichage). Vous pouvez modifier ces paramètres à l'aide de SetViewPort.

Function GetX:SmallInt;

Cette fonction permet de retourner la coordonnée x de la position actuelle du pointeur graphique en pixels. Il est compris entre 0 et GetMaxX. Il augmente de gauche à droite.

Function GetY:SmallInt;

Cette fonction permet de retourner la coordonnée y de la position actuelle du pointeur graphique en pixels. Il est compris entre 0 et GetMaxY. Il augmente de haut en bas.

Procedure GraphDefaults;

Cette procédure permet de réinitialiser les paramètres graphiques à leurs valeurs par défaut pour la palette, le style de ligne, les couleurs de premier plan et d'arrière-plan, le motif et le style de remplissage, le style et le placement du texte, la fenêtre d'affichage, le mode d'écriture et les proportions. Cette routine est d'abord utilisée par InitGraph.

Function GraphEnabled:Boolean;

Cette fonction permet de tester si la fenêtre graphique est activée. Si c'est le cas, vous pouvez effectuer des graphiques. Habituellement, après InitGraph, cette routine renvoie True et, après CloseGraph, elle renvoie False.

Function GraphErrorMsg(ErrorCode:SmallInt):ShortString;

Cette fonction permet de retourner une chaîne de caractères décrivant l'erreur (errorcode). Cette chaîne de caractères peut être utilisée pour informer l'utilisateur de ce qui s'est mal passé. Nous avons les types de codes d'erreur suivants :

Constante Description
grOk Pas d'erreur
grInvalidDriver Pilote graphique invalide
grInvalidMode Mode graphique invalide
grNotWindow La création de la fenêtre graphique a échoué
grNoInitGraph Fenêtre graphique non initialisée
grInvalidFont Sélection de police de caractères invalide
grInvalidFontNum Numéro de police invalide
grInvalidParam Valeur de paramètre invalide
grSansPalette Aucune palette disponible
grNoOpenGL Pilote OpenGL non initialisé
grError Erreur graphique générale

Utilisez GraphResult pour renvoyer un code d'erreur.

Function GraphResult:SmallInt;

Cette fonction permet de retourner un code d'erreur pour la dernière opération graphique. Si la valeur renvoyée est zéro (grOK), tout s'est bien passé. Une valeur différente de zéro signifie qu'une erreur s'est produite. La plupart des routines dessinant quelque chose à l'écran, définissent ou interrogent certains attributs de dessin peuvent produire un GraphResult différent de zéro. L'appel de cette routine une fois réinitialisera le code d'erreur à zéro. GraphResult doit être utilisé après InitGraph pour découvrir les problèmes d'initialisation, car cette routine peut échouer dans certaines situations : le pilote graphique et le mode ne sont pas pris en charge, ou les polices de caractères par défaut ne peuvent pas être installées, ou le pilote OpenGL ne peut pas être initialisé,... Chaque code d'erreur est associé à un message d'erreur. Utilisez GraphErrorMsg pour obtenir ce message.

Function ImageSize(x1,y1,x2,y2:SmallInt):LongInt;

Cette fonction permet de retourner le nombre d'octets nécessaires pour entreposer l'image à partir du rectangle défini par les coordonnées (x1,y1,x2,y2). Il doit être utilisé avant d'appeler GetImage et PutImage.

Procedure InitGraph(Var Driver,Mode:SmallInt; Const Title:ShortString);

Cette procédure permet d'initialiser la fenêtre graphique. Les pilotes graphiques (Driver) sont :

Constante Description
D1bit 2 couleurs
D4bit 16 couleurs
D8bit 256 couleurs
Detect La routine DetectGraph est utilisée
NoPalette Pas de palette, toutes les couleurs du système sont disponibles

Il existe également les constantes suivantes : HercMono=D1bit, VGA=D4bit, SVGA=D8bit.

Si vous sélectionnez un pilote avec palette, vous obtenez un nombre limité de couleurs disponibles (les entrées de la palette, 256 ou moins). Voir aussi SetAllPalette. Si le pilote NoPalette est sélectionné, toutes les couleurs générées par le système sont disponibles. Les noms de couleur sont cartographiés à leurs valeurs RVB prédéfinies. Si driver=Detect alors InitGraph retourne en (driver) et (mode) leurs valeurs par défaut données par DetectGraph et initialise la fenêtre graphique.

Les modes graphiques (mode) sont :

Constante Description
m320x200 320x200 pixels
m640x200 640x200 pixels
m640x350 640x350 pixels
m640x480 640x480 pixels
m720x350 720x350 pixels
m800x600 800x600 pixels
m1024x768 1024x768 pixels
m1280x1024 1280x1024 pixels
mDefault Taille par défaut donnée par le système Windows
mMaximized Une fenêtre maximisée (avec barre de légende)
mFullScr Une fenêtre plein écran (pas de barre de légende)
mCustom Une fenêtre de taille personnalisée (utilisez d'abord SetWindowSize pour définir ses dimensions)

Les constantes sont également définit : HercMonoHi=m720x350, VGALo=m640x200, VGAMed=m640x350, VGAHi=m640x480.

Tous les modes pour lesquels la fenêtre graphique tient dans l'écran (avec ou sans barre de légende) sont valides. Le troisième paramètre (title), s'il n'est pas vide, définit le titre de la fenêtre graphique, sinon ce titre est défini sur la chaîne de version de WinGraph (WinGraphVer).

La routine définit les attributs de la fenêtre graphique et crée un fil dédié pour envoyer des messages à la fenêtre. Avant de revenir, il définit la page active, installe plusieurs polices par défaut, appelle GraphDefaults pour obtenir les paramètres par défaut des dessins, active le pilote OpenGL (si la condition INIT_OPENGL est définie dans le code source) et masque la fenêtre de la console parente (le cas échéant et si la condition HIDE_CONSOLE est défini également dans le code source). Voir GraphResult pour les éventuels problèmes d'échec.

La plupart des routines WinGraph ne font rien d'utile avant l'appel d'InitGraph. Quoi qu'il en soit, les suivants fonctionnent : DetectGraph, GetDefaultPalette, GetNamesPalette, GetMaxMode, GetModeName, GetModeRange, GraphEnabled, GraphErrorMsg, GraphResult, ImageSize, InitGraph, GetRGBColor, GetRGBComponents, SetGraphMode et SetWindowSize. Utilisez CloseGraph pour fermer la fenêtre graphique.

Function InstallUserFont(Const FontName:ShortString):SmallInt;

Cette fonction permet d'installer une nouvelle police de caractères et renvoie son index dans la table des polices de caractères installées. Cet index peut être utilisé avec SetTextStyle pour activer la police de caractères des textes. Le paramètre (fontname) doit être un nom de police de famille valide enregistré dans le système (exemple : 'Fixedsys'). Le nom est sensible à la casse. Si la police de caractères ne peut pas être enregistrée, InstallUserFont renverra -1. InitGraph installe plusieurs polices de caractères à l'aide de cette routine. La police de caractères par défaut est définie sur 'Courier New'.

Procedure InvertRect(x1,y1,x2,y2:SmallInt);

Cette procédure permet d'effectuer une opération NOT logique sur les valeurs de couleur pour chaque pixel dans le rectangle spécifié défini par les coordonnées (x1,y1,x2,y2). Sur le pilote monochrome, InvertRect rend les pixels blancs noirs et les pixels noirs blancs. Sur les pilotes de couleur, l'inversion dépend de la façon dont les couleurs sont générées. Appeler InvertRect deux fois pour le même rectangle restaure l'affichage à ses couleurs précédentes. Il ne fonctionne pas bien sur les pilotes basés sur la palette. Voir aussi SetWriteMode.

Procedure Line(x1,y1,x2,y2:SmallInt);

Cette procédure permet de dessiner une ligne allant de (x1,y1) à (x2,y2), en utilisant la couleur de premier plan et le style de ligne actuels. La position actuelle est déplacée vers (x2,y2).

Procedure LineRel(dx,dy:SmallInt);

Cette procédure permet de dessiner une ligne à partir de la position actuelle du pointeur jusqu'au point (dx,dy), par rapport à la position actuelle, en utilisant la couleur de premier plan et le style de ligne actuels. La position actuelle est déplacée vers l'extrémité de la ligne.

Procedure LineTo(x,y:SmallInt);

Cette procédure permet de dessiner une ligne à partir de la position actuelle du pointeur jusqu'au point (x,y), en utilisant la couleur et le style de ligne actuels. La position actuelle est déplacée vers (x,y). Utilisez la routine SetLineStyle pour définir les attributs de la ligne et SetColor pour définir sa couleur. Utilisez MoveTo pour modifier la position actuelle du pointeur. Pour tracer une ligne avec des coordonnées absolues, utilisez plutôt la routine Line.

Procedure MoveRel(dx,dy:SmallInt);

Cette procédure permet de déplacer le pointeur aux coordonnées (dx,dy), par rapport à la position actuelle du pointeur.

Procedure MoveTo(x,y:SmallInt);

Cette procédure permet de déplacer le pointeur vers les coordonnées (x,y) étant relatives à la fenêtre.Seules les routines suivantes utilisent ou déplacent le pointeur actuel : ClearDevice, ClearViewPort, GraphDefaults, Line, LineRel, LineTo, MoveRel, MoveTo, OutText, OutTextXY, SetViewPort. Aucune vérification n'est effectuée concernant l'intervalle de coordonnées.

Function OpenGLEnabled:Boolean;

Cette fonction permet de vérifier si le pilote OpenGL est initialisé. Sinon, vous ne pouvez pas effectuer de dessins OpenGL. Cela peut se produire si la condition INIT_OPENGL n'est pas activée dans le code source ou si le pilote graphique actuellement sélectionné ne prend pas en charge l'initialisation OpenGL. Le pilote graphique D1bit ne prend pas en charge les dessins OpenGL. Le pilote OpenGL peut être initialisé de deux manières.

Procedure OutText(Const TextString:ShortString);

Cette procédure permet de placer une chaîne de caractères de texte à l'écran, à la position actuelle du pointeur, en utilisant les paramètres de police de caractères et de texte actuels. La position actuelle est déplacée à la fin du texte. Utilisez SetTextStyle pour modifier le style de police et SetTextJustify pour modifier l'alignement du texte. Pour placer du texte sur un emplacement absolu, utilisez plutôt OutTextXY.

Procedure OutTextXY(x,y:SmallInt;Const TextString:ShortString);

Cette procédure permet de placer (textstring) à l'écran, aux coordonnées (x,y), en utilisant les paramètres de police et de texte actuels. La position actuelle est déplacée à la fin du texte.

Procedure PieSlice(x,y:SmallInt;Start,Stop,Radius:Word);

Cette procédure permet de dessiner et de remplir un secteur circulaire (une région délimitée par l'intersection d'un cercle et de deux radiales - appelée tranche de tarte). Il utilise la couleur de premier plan et le style de remplissage actuels. Les paramètres ont le même sens que dans Arc. Pour dessiner un disque entier, utilisez FillEllipse. PieSlice est un cas particulier de Sector.

Procedure PutAnim(x1,y1:SmallInt;Var Anim:AnimatType;Bit:Word);

Cette procédure permet de placer l'animation avec le descripteur spécifiée (anim) à l'écran aux coordonnées données (x1,y1). Une telle animation est préalablement créée avec GetAnim. Le paramètre (bit) détermine comment l'animation sera placée. Les valeurs prédéfinies incluent celles de la routine PutImage et, en plus :

Constante Description
TransPut Copie l'animation à l'écran avec la couleur transparente activée.
MaskPut Copie le masque d'animation à l'écran
BkgPut Copie l'arrière-plan de l'animation (extrait du PutAnim précédent) à l'écran

Dans les pilotes basés sur palette, les couleurs de l'animation sont cartographiées aux entrées de la palette. Quoi qu'il en soit, comme la palette n'est qu'une palette logique, vous devez utiliser la routine UpdateGraph pour vous assurer que l'animation à l'écran a la même composition de couleurs que celle qui apparaît dans la page active. Pour la même raison, les opérations raster ne fonctionnent pas bien sur ces pilotes.

PutAnim est généralement plus rapide que PutImage.

Procedure PutImage(x1,y1:SmallInt;Var Bitmap;Bit:Word);

Cette procédure permet de placer l'image de (bitmap) sur l'écran à (x1,y1). Le paramètre (bit) détermine comment le bitmap sera placé. Les valeurs prédéfinies sont :

Constante Description
CopyPut Copie le bitmap directement à l'écran.
XorPut Combine les couleurs du bitmap et de l'écran en utilisant l'opérateur logique XOR.
OrPut Combine les couleurs du bitmap et de l'écran en utilisant l'opérateur logique OR
AndPut Combine les couleurs du bitmap et de l'écran en utilisant l'opérateur logique AND
NotPut Copie le bitmap inversé à l'écran
NotOrPut Combine les couleurs du bitmap et de l'écran en utilisant l'opérateur logique OR, puis inverse la couleur résultante
InvBitOrPut Combine les couleurs du bitmap inversé avec les couleurs de l'écran en utilisant l'opérateur logique OR
InvScrAndPut Combine les couleurs inversées de l'écran avec les couleurs du bitmap en utilisant l'opérateur logique AND

La constante est aussi défini : NormalPut=CopyPut.

Dans les pilotes basés sur la palette, les couleurs du bitmap sont cartographiées aux entrées de la palette. Quoi qu'il en soit, comme la palette n'est qu'une palette logique, vous devez utiliser la routine UpdateGraph pour vous assurer que le bitmap à l'écran a la même composition de couleurs que celle qui apparaît dans la page active. Pour la même raison, les opérations raster ne fonctionnent pas bien sur ces pilotes.

Avec PutImage vous pouvez mettre à l'écran n'importe quelle image BMP externe au format 24 bits. Voir GetImage pour plus de détails.

Si vous souhaitez réaliser des animations, pensez à utiliser PutAnim.

Procedure PutPixel(x,y:SmallInt;Color:LongWord);

Cette procédure permet de placer un point à la position (x,y) en utilisant la couleur (color). Cochez SetColor pour en savoir plus sur les valeurs de couleur. Utilisez GetPixel pour récupérer une couleur de pixel.

Procedure Rectangle(x1,y1,x2,y2:SmallInt);

Cette procédure permet de dessiner un rectangle défini par le coin supérieur gauche (x1,y1) et le coin inférieur droit (x2,y2). Il utilise la couleur de premier plan et le style de ligne actuels. Pour dessiner un rectangle plein, utilisez FillRect. Rectangle est un cas particulier de DrawPoly.

Procedure RestoreCrtMode;

Cette procédure permet de restaurer le mode CRT. Cette procédure est tout à fait équivalent avec CloseGraph. Peut être utilisé en combinaison avec SetGraphMode.

Procedure RotEllipse(x,y,rot:SmallInt;xradius,yradius:Word);

Cette procédure permet de dessiner une ellipse pivotée dont le centre est à (x,y). Les paramètres (xradius) et (yradius) sont les rayons horizontal et vertical de l'ellipse, (rot) définit l'angle de rotation mesuré dans le sens antihoraire en degrés. Il utilise la couleur de premier plan actuelle. Il est implémenté à l'aide de DrawBezier.

Procedure RoundRect(x1,y1,x2,y2,r:SmallInt);

Cette procédure permet de dessiner et de remplir un rectangle avec des coins arrondis, en utilisant la couleur de premier plan, le style de remplissage et la couleur actuels. Le paramètre (r) est le rayon d'un cercle utilisé pour dessiner les coins. Les autres paramètres sont les mêmes que dans Rectangle.

Procedure Sector(x,y:SmallInt;Start,Stop,XRadius,YRadius:Word);

Cette procédure permet de dessiner et de remplir un secteur elliptique (une région délimitée par l'intersection d'une ellipse et de deux radiales). Il utilise la couleur de premier plan et le style de remplissage actuels. Les paramètres ont la même signification que dans Ellipse. Pour dessiner un secteur de cercle, utilisez PieSlice.

Procedure SetActivePage(Page:Word);

Cette procédure permet de définir la page active où tous les dessins sont exécutés. S'ils sont différents de la page visuelle, ces dessins n'apparaissent pas à l'écran. Au moins 4 pages actives existent (commençant par 0), mais ce nombre peut être augmenté à partir du code source. Cette routine peut être utilisée pour créer plusieurs sorties. Par programme, une page active est une copie mémoire de la fenêtre graphique. Cette copie est également utilisée par le fil de messagerie pour rafraîchir la fenêtre graphique si nécessaire. Vous pouvez utiliser la routine UpdateGraph pour actualiser la fenêtre graphique avec le contenu de la page active actuelle. Ceci est utile si les dessins ne sont pas exécutés directement sur la fenêtre graphique.

Procedure SetAllPalette(Var Palette);

Cette procédure permet de définir la palette actuelle sur celle spécifiée. (palette) est une variable non typée, pointant généralement vers un enregistrement de type PaletteType. Après avoir modifié le contenu de la palette, les couleurs à l'écran sont mises à jour instantanément. Pour modifier uniquement certaines entrées de la palette, utilisez SetRGBPalette. Le champ (size) de la structure PaletteType donne le nombre de couleurs dans la palette et le champ (couleurs) doit contenir des valeurs de couleur RVB absolues. De telles valeurs peuvent être générées avec la routine GetRGBColor, avant d'appeler InitGraph. Les noms de couleur (Rouge, Vert, ...) ne sont pas des constantes, mais des variables étant cartographiées aux entrées les plus proches dans la palette sélectionnée. Selon la palette choisie, le résultat n'est pas toujours comme leurs noms l'indiquent. Étant donné que la palette n'est qu'une palette logique, la modification des entrées de la palette peut nécessiter de redéfinir les couleurs de premier plan et d'arrière-plan. Sinon, les anciennes couleurs en dehors de l'intervalle de la palette pourraient rester utilisées.

Procedure SetAspectRatio(xasp,yasp:Word);

Cette procédure permet de définir le rapport d'aspect de l'écran au rapport donné par xasp/yasp. Cela n'affecte que les routines pour les formes circulaires. N'a pas d'utilisation pratique autre que la rétrocompatibilité avec Borland Pascal. Les valeurs par défaut sont (10000,10000).

Procedure SetBkColor(Color:LongWord);

Cette procédure permet de définir la couleur d'arrière-plan sur (color). La couleur d'arrière-plan est la couleur utilisée pour effacer des parties de l'écran (ou la totalité de la fenêtre). Il est également utilisé comme double couleur dans les motifs de remplissage. SetBkColor n'affecte que les dessins suivants. La couleur par défaut est le noir.

Procedure SetColor(Color:LongWord);

Cette procédure permet de définir la couleur de premier plan sur (color). Pour les pilotes basés sur palette, la valeur de (couleur) est un index dans la palette. Pour le pilote sans palette de couleur, elle entrepose une valeur RVB 24 bits codée sous forme hexadécimale. L'octet de poids faible contient une valeur pour l'intensité relative du rouge, le deuxième octet contient une valeur pour le vert et le troisième octet contient une valeur pour le bleu (exemple $0000FF est rouge). Dans les deux cas, des noms de couleurs prédéfinis peuvent être utilisés à la place de nombres purs. La couleur de premier plan est la couleur utilisée pour dessiner les contours, les lignes et le texte. D'autres primitives ont différentes manières de spécifier la couleur. La couleur par défaut est le blanc.

Procedure SetFillPattern(FillPattern:FillPatternType;Color:LongWord);

Cette procédure permet de sélectionner un motif de remplissage défini par l'utilisateur étant utilisé dans la routine SetFillStyle avec l'ensemble de hachures UserFill. Le motif est un raster 8x8, correspondant aux 64 bits dans (fillpattern). La couleur du motif de premier plan est définie sur (color). La valeur par défaut est White (Blanc). La couleur du motif d'arrière-plan est la couleur d'arrière-plan sélectionnée par SetBkColor. Avant de revenir, il appelle la routine SetFillStyle pour appliquer le modèle.

Procedure SetFillStyle(Pattern:Word;Color:LongWord);

Cette procédure permet de définir le motif de remplissage et la couleur des routines de dessins remplis. Le paramètre (Pattern) peut être l'une des constantes suivantes :

Constante Description
EmptyFill Hachure de couleur d'arrière-plan
SolidFill Hachures pleines
LineFill Hachures horizontales
ColFill Hachure verticale
HatchFill Hachures croisées horizontales et verticales
SlashFill 45 degrés vers le haut, trappe de gauche à droite
BkSlashFill 45 degrés vers le bas, trappe de gauche à droite
XHatchFill Hachures croisées à 45 degrés
UserFill Hachure définie par l'utilisateur
NoFill Pas de trappe

Si (pattern) est égal à UserFill, le modèle défini par l'utilisateur défini par SetFillPattern devient le modèle actif. Dans ce cas, le paramètre (color) est ignoré. Le paramètre (color) est utilisé pour remplir les formes. La valeur par défaut est White (blanc). Cochez SetColor pour en savoir plus sur les valeurs de couleur.

Procedure SetFloodMode(FloodMode:SmallInt);

Cette procédure permet de définir le mode dans lequel les remplissages de surface sont effectués avec la routine FloodFill. Le paramètre (floodmode) a les valeurs prédéfinies suivantes :

Constante Description
BorderFlood La zone de remplissage est délimitée par la couleur spécifiée dans FloodFill ; le remplissage commence au point spécifié et continue dans toutes les directions jusqu'à ce qu'il atteigne la couleur délimitant la zone ; c'est la valeur par défaut.
SurfaceFlood La zone de remplissage est définie par la couleur spécifiée dans FloodFill ; le remplissage commence au point spécifié et continue dans toutes les directions sur toutes les régions adjacentes contenant la couleur spécifiée ; ce mode est utile pour remplir des zones avec des bordures multicolores.

Procedure SetGraphMode(Mode:SmallInt);

Cette procédure permet de rétablir la fenêtre graphique à l'écran en utilisant le mode graphique (mode) et le pilote sélectionné précédemment. Tous les paramètres graphiques précédents sont perdus. Il doit être utilisé après CloseGraph ou RestoreCRTMode.

Procedure SetLineStyle(LineStyle,Pattern,Thickness:Word);

Cette procédure permet de définir le style de dessin des lignes. Le (linestyle) est l'une des constantes suivantes :

Constante Description
SolidLn ligne continue
DashedLn Ligne pointillée
DottedLn Ligne pointillée
DashDotLn Ligne alternée de tirets et de points
DashDotDotLn Tirets et ligne de points doubles
UserBitLn Ligne définie par l'utilisateur
NullLn Ligne invisible

Si UserBitLn est spécifié, alors (modèle) doit contenir le modèle 16 bits. Dans tous les autres cas (pattern) est ignoré. Le paramètre (thickness) indique l'épaisseur de la ligne :

Constante Description
NormWidth Largeur d'un pixel
DoubleWidth Largeur de deux pixels
TripleWidth Largeur de trois pixels
QuadWidth Largeur de quatre pixels

Il existe aussi la constante ThickWidth=TripleWidth.

Si (thickness) <> NormWidth alors (linestyle) est ignoré et la ligne est tracée solide, en raison des limitations du GDI de Windows. (thickness) est ignoré pour le style UserBitLn en raison d'une implémentation manquante. Utilisez SetColor pour définir la couleur de la ligne.

Procedure SetOpenGLMode(Direct:Boolean);

Cette procédure permet de changer le mode de dessin pour les routines OpenGL. Le paramètre (Direct) est l'une des constantes suivantes :

Constante Description
DirectOff Le pilote OpenGL n'écrit pas directement à l'écran.
DirectOn Le pilote OpenGL écrit directement à l'écran.

Dans le premier mode (DirectOff), tous les dessins OpenGL sont exécutés dans le tampon OpenGL. Pour cette raison, vous devez utiliser la fonction spécifique glFlush() d'OpenGL pour libérer ce tampon dans la page active après chaque cadre. Ce mode est principalement utilisé pour les dessins OpenGL statiques lorsque la vitesse n'est pas si importante. Dans les pilotes basés sur palette, les dessins OpenGL sont affectés par la palette sélectionnée. C'est le mode par défaut.

Dans le second mode (DirectOn), tous les dessins OpenGL sont exécutés directement à l'écran. Cela signifie des graphiques à grande vitesse, mais aucune possibilité de conserver une copie de la sortie OpenGL dans la page active. Ce mode est principalement utilisé pour les images dynamiques lorsque la vitesse est importante. Les dessins OpenGL ne sont pas affectés par la palette sélectionnée.

Dans les deux modes, vous devez utiliser UpdateGraph(UpdateNow) après chaque image, afin de mettre à jour l'écran. Lors du changement de mode OpenGL, tous les paramètres OpenGL précédents sont perdus.

Vous pouvez mélanger les routines OpenGL et WinGraph, mais cela n'est généralement pas recommandé. Si vous le faites, gardez à l'esprit ce qui suit : en mode (DirectOff), les routines WinGraph doivent être appelées après la fonction glFlush() et UpdateGraph(UpdateOff) doit être activé en premier pour éviter les mises à jour d'écran entre les commandes ; en mode (DirectOn), vous pouvez mélanger ces routines comme vous le souhaitez, mais un scintillement de l'écran peut apparaître.

Avant d'appeler les routines OpenGL, vous devez vérifier avec OpenGLEnabled si le pilote OpenGL est initialisé. Voir cette routine pour plus de détails.

Procedure SetPalette(NrColor,Color:Word);

Cette procédure permet de modifier la (nrcolor)-ième entrée dans la palette actuelle avec la valeur (color). Ce paramètre (color) est un index dans la palette VGA par défaut, renvoyé par GetDefaultPalette. Il est compris entre 0 et 255, il n'est donc pas limité à la taille de palette actuelle. Pour modifier une entrée de palette avec une vraie couleur, utilisez SetRGBPalette à la place.

Procedure SetRGBPalette(NrColor,R,G,B:Word);

Cette procédure permet de définir l'entrée de palette actuelle (nrcolor) avec une valeur RVB absolue : (r)-rouge, (g)-vert, (b)-bleu. Ces paramètres sont compris entre 0 et 255. Les noms de couleur ne sont pas cartographiés à la nouvelle entrée de palette.

Procedure SetTextJustify(Horiz,Vert:Word);

Cette procédure permet de contrôler l'emplacement du nouveau texte, par rapport à la position du curseur. Le paramètre (Horiz) contrôle le placement horizontal et peut être l'une des constantes prédéfinies suivantes :

Constante Description
LeftText Le texte est défini à gauche du pointeur
CenterText Le texte est centré horizontalement sur le pointeur
RightText Le texte est placé à droite du pointeur

Le paramètre (Vert) contrôle le placement vertical du texte. Sa valeur peut être l'une des constantes prédéfinies suivantes :

Constante Description
TopText Le texte est placé au-dessus du pointeur
BottomText Le texte est placé sous le pointeur
BaselineText Le texte est placé par rapport à sa ligne de base

Le placement de texte par défaut est LeftText et TopText.

Procedure SetTextStyle(Font,Direction,CharSize:Word);

Cette procédure permet de contrôler le style du texte à afficher à l'écran. Les constantes prédéfinies pour (Font) sont :

Constante Description
CourierNewFont Police de caractères Courier New
MSSansSerifFont Police de caractères MS Sans Serif
TimesNewRomanFont Police de caractères Times New Roman
ArialFont Police de caractères Arial

La valeur par défaut est DefaultFont=CourierNewFont.

En outre, toute police utilisateur installée avec succès peut être utilisée à la place. Voir InstallUserFont pour plus de détails. Toutes ces polices de caractères peuvent être appliqué avec OR avec les styles supplémentaires suivants pour changer leur apparence :

Constante Description
ItalicFont Police de caractères italique.
UnderlineFont Police de caractères soulignée.
BoldFont Police de caractères en gras.

Le paramètre (Direction) définit la direction du texte. Il peut s'agir de n'importe quelle valeur positive en degrés ou de l'une des constantes suivantes :

Constante Description
HorizDir=0 Direction horizontale.
VertDir=90 Direction verticale.

Entre 1 et 5, (CharSize) représente le grossissement des caractères avec une taille de police standard de 8 pixels. Au-dessus de 6, il représente une taille de police absolue. La valeur par défaut est 16.

Sachez que certaines polices (y compris prédéfinies) ne supportent pas tous ces styles. Voir la routine GetFontSettings pour plus de détails. Utilisez SetColor pour définir la couleur du texte.

Procedure SetUserCharSize(nCharExtra,nBreakExtra,Dummy1,Dummy2:Word);

Cette procédure permet de définir la taille d'une police de caractères utilisateur. Le premier paramètre (nCharExtra) définit l'espacement entre les caractères dans le texte et le second (nBreakExtra) définit la quantité d'espace réservée au caractère de rupture. Les autres sont des paramètres factices (non utilisés). Il s'agit d'une incompatibilité majeure avec l'unité Graph de Borland Pascal. Les valeurs par défaut sont zéro.

Procedure SetViewPort(x1,y1,x2,y2:SmallInt;Clip:Boolean);

Cette procédure permet de définir la fenêtre de sortie actuelle sur le rectangle défini par le coin supérieur gauche (x1, y1) et le coin inférieur droit (x2, y2). Si (clip) est vrai, tout ce qui est dessiné à l'extérieur de la fenêtre sera coupé (non dessiné). Les coordonnées spécifiées après cet appel sont relatives au coin supérieur gauche de la fenêtre. La position du curseur est réinitialisée à (0,0). La position du curseur est réinitialisée à (0,0). Les constantes d'écrêtage suivantes sont définies :

Constante Description
ClipOn=True Tout ce qui est dessiné à l'extérieur de la fenêtre sera coupé (non dessiné)
ClipOff=False Rien ne sera coupé en dehors de la fenêtre.

Les dessins OpenGL ne sont pas limités à la fenêtre.

Procedure SetVisualPage(Page:Word);

Cette procédure permet de définir la page visuelle à afficher dans la fenêtre graphique. UpdateGraph utilise cette routine pour forcer l'actualisation de l'écran.

Procedure SetWindowSize(Width,Height:Word);

Cette procédure permet de définir les dimensions de la fenêtre graphique à créer par InitGraph. Dans ce cas, vous devez utiliser le mode graphique mCustom. (width) est la largeur et (height) est la hauteur en pixels de la zone client de la fenêtre.

Procedure SetWriteMode(WriteMode:SmallInt);

Cette procédure permet d'indiquer quelle opération binaire est effectuée lors du dessin à l'écran. Le paramètre (writemode) a deux composantes. La première composante est le mode de mixage de premier plan. Elle affecte les contours (y compris les lignes) et les formes remplies (à l'exception de Bar). Il peut s'agir de l'une des constantes prédéfinies suivantes :

Constante Description
CopyMode Les pixels sont simplement copiés sur l'écran
XorMode Les pixels sont une combinaison de la couleur du dessin et de la couleur de l'écran, mais pas dans les deux (XOR logique).
OrMode Les pixels sont une combinaison de la couleur du dessin et de la couleur de l'écran (OR logique).
AndMode Les pixels sont une combinaison des couleurs communes au dessin et à l'écran (AND logique).
NotMode Les pixels sont l'inverse de la couleur du dessin (NOT logique).
NotScrMode Les pixels sont l'inverse de la couleur de l'écran.
NotXorMode Les pixels sont l'inverse de la couleur XorMode.
NotOrMode Les pixels sont l'inverse de la couleur OrMode.
NotAndMode Les pixels sont l'inverse de la couleur AndMode.
InvColAndMode Les pixels sont une combinaison des couleurs communes à la fois à l'écran et à l'inverse de la couleur du dessin.
InvColOrMode Les pixels sont une combinaison de la couleur de l'écran et de l'inverse de la couleur du dessin.
InvScrAndMode Les pixels sont une combinaison des couleurs communes au dessin et à l'inverse de la couleur de l'écran.
InvScrOrMode Les pixels sont une combinaison de la couleur du dessin et de l'inverse de la couleur de l'écran.
BlackMode Les pixels sont toujours 0.
WhiteMode Les pixels sont toujours 1.
EmptyMode Les pixels de l'écran restent inchangés.

La deuxième composante est le mode de mixage d'arrière-plan. Cela n'affecte que les textes. Il peut s'agir de l'une des deux constantes prédéfinies suivantes :

Constante Description
Transparent L'écran reste intact (comme dans l'unité Graph de Borland Pascal).
Opaque L'écran est rempli avec la couleur d'arrière-plan actuelle avant que le texte ne soit dessiné.

Le paramètre (writemode) est une combinaison OR des modes de mixage de premier plan et d'arrière-plan. Par défaut, il est égal à CopyMode OR Transparent.

La procédure SetWriteMode ne fonctionne pas bien sur les pilotes basés sur palette, en particulier si la palette n'a pas été récupérée par la routine GetSystemPalette. Quoi qu'il en soit, comme la palette n'est qu'une palette logique, vous devez utiliser la routine UpdateGraph pour vous assurer que l'écran a la même composition de couleurs que la page active.

Vous pouvez utiliser InvertRect pour effectuer des opérations NOT logiques sur le contenu de l'écran.

Function TextHeight(Const TextString:ShortString):Word;

Cette fonction permet de retourner la hauteur (en pixels) de (textstring) dans le style de police de caractères actuel. Cette valeur peut être modifiée par un appel à SetTextStyle ou SetUserCharSize.

Function TextWidth(Const TextString:ShortString):Word;

Cette fonction permet de retourner la largeur (en pixels) de (textstring) dans le style de police de caractères actuel. Cette valeur peut être modifiée par un appel à SetTextStyle ou SetUserCharSize.

Procedure UpdateGraph(Bit:Word);

Cette procédure permet de gérer toutes les opérations graphiques. Par défaut, ces opérations sont effectuées simultanément sur la fenêtre graphique et en mémoire (la page active en cours). Cependant, vous pouvez modifier ce comportement avec UpdateGraph. La signification de (bit) est la suivante :

Constante Description
UpdateOff Les opérations graphiques ne sont pas effectuées directement à l'écran, uniquement sur la mémoire (vous pouvez gagner un peu de vitesse ici).
UpdateOn Les opérations graphiques sont également effectuées directement à l'écran (c'est la valeur par défaut).
UpdateNow L'écran est mis à jour avec le contenu de la page active actuelle en ce moment ; utilisé conjointement avec UpdateOff.

Cette routine est utile pour synchroniser la sortie de plusieurs opérations graphiques, afin de réduire le scintillement de l'écran. De plus, vous devez utiliser UpdateGraph(UpdateNow) pour forcer la mise à jour de l'écran après chaque frame OpenGL. Voir SetOpenGLMode pour plus de détails.

Routines WinCrt

L'unité WinCrt ajoute la prise en charge du clavier à WinGraph. La fenêtre graphique doit être activée avec InitGraph afin d'utiliser correctement cet unité.

Procedure Delay(ms:Word);

Cette procédure permet de retarder le processus léger principal d'un nombre spécifié de millisecondes (ms). Les événements clavier et souris sont toujours enregistrés. Vous pouvez utiliser cette routine dans une boucle d'attente (comme Delay(10)), si vous voulez que votre programme ne consomme pas la plupart des cycles de microprocesseur. Les routines ReadBuf et ReadKey utilisent cette technique. Le nombre spécifié est une approximation, le résultat peut être très erroné si la charge du système est élevée.

Function KeyPressed:Boolean;

Cette fonction permet d'analyser la mémoire tampon du clavier et voit si une touche a été enfoncée. Si tel est le cas, True est renvoyé. Sinon, False est retourné. Les touches Shift, Alt et Ctrl ne sont pas signalées. La touche n'est pas supprimée de la mémoire tampon et peut donc toujours être lue après l'appel de la fonction KeyPressed, à l'aide de la routine ReadKey.

Procedure ReadBuf(Out buf:ShortString;MaxChar:Byte);

Cette procédure permet d'émuler la routine de console de lecture pour WinGraph. Il crée un caret clignotant et attend que l'utilisateur saisisse plusieurs touches jusqu'à ce que la touche Enter (#13) soit enfoncée ou qu'un nombre de caractères (maxchar) soit atteint. Si (maxchar) est défini sur 0, 255 caractères au maximum sont acceptés. Le paramètre (buf) entreposera la séquence de caractères d'entrée. L'intervalle ASCII acceptée est comprise entre ' ' (espace) et '~' (tilde). Les touches étendues ou de fonction sont ignorées. Parmi les touches d'édition habituelles, seul BackSpace est reconnu. La routine utilise DefaultFont pour écrire les caractères horizontalement à l'écran et gérer elle-même le placement et les espaces intercaractères. Tous les autres styles de texte spécifiés par l'utilisateur sont pris en compte. Le texte est positionné à l'emplacement actuel du pixel. L'écran entier défile vers le haut si nécessaire. L'appel suivant de ReadBuf place le caret sur une nouvelle ligne.

Function ReadKey:Char;

Cette fonction permet de retourner une touche du tampon du clavier. Si une touche étendue ou de fonction a été enfoncée, le code ASCII zéro est renvoyé (#0). Vous pouvez ensuite lire le code de numérisation de la touche avec un deuxième appel ReadKey. La plupart des codes de touches d'une console DOS sont implémentés dans WinCrt, ainsi que de nombreux autres. Voir ci-dessous pour une liste complète :

Touche Normal Shift Ctrl Alt
A #97 #65 #1 #0#30
B #98 #66 #2 #0#48
C #99 #67 #3 #0#46
D #100 #68 #4 #0#32
E #101 #69 #5 #0#18
F #102 #70 #6 #0#33
G #103 #71 #7 #0#34
H #104 #72 #8 #0#35
I #105 #73 #9 #0#23
J #106 #74 #10 #0#36
K #107 #75 #11 #0#37
L #108 #76 #12 #0#38
M #109 #77 #13 #0#50
N #110 #78 #14 #0#49
O #111 #79 #15 #0#24
P #112 #80 #16 #0#25
Q #113 #81 #17 #0#16
R #114 #82 #18 #0#19
S #115 #83 #19 #0#31
T #116 #84 #20 #0#20
U #117 #85 #21 #0#22
V #118 #86 #22 #0#47
W #119 #87 #23 #0#17
X #120 #88 #24 #0#45
Y #121 #89 #25 #0#21
Z #122 #90 #26 #0#44
0 ) #48 #41 #0#10 #0#129
1 ! #49 #33 #0#1 #0#120
2 @ #50 #64 #0#2 #0#121
3 # #51 #35 #0#3 #0#122
4 $ #52 #36 #0#4 #0#123
5 % #53 #37 #0#5 #0#124
6 ^ #54 #94 #0#6 #0#125
7 & #55 #38 #0#7 #0#126
8 * #56 #42 #0#8 #0#127
9 ( #57 #40 #0#9 #0#128
` ~ #96 #126 - -
- _ #45 #95 - -
= + #61 #43 - -
\ | #92 #124 #28 -
[ } #91 #123 #27 -
] } #93 #125 #29 -
; : #59 #58 - -
' " #39 #34 - -
, < #44 #60 - -
. > #46 #62 - -
/ ? #47 #63 - -
Barre d'espacement #32 #32 #32 #0#11
Tab #9 #9 #30 -
Caps Lock - - - -
BackSpace #8 #8 #127 #0#14
Enter #13 #13 #10 #0#166
APP KEY #0#151 #0#151 #0#151 #0#151
Windows - - - -
INS #0#82 #0#82 #0#146 #0#162
DEL #0#83 #0#83 #0#147 #0#163
HOME #0#71 #0#71 #0#119 #0#164
END #0#79 #0#79 #0#117 #0#165
PAGE UP #0#73 #0#73 #0#132 #0#153
PAGE DOWN #0#81 #0#81 #0#118 #0#161
↑ #0#72 #0#72 #0#141 #0#152
↓ #0#80 #0#80 #0#145 #0#160
← #0#75 #0#75 #0#115 #0#155
→ #0#77 #0#77 #0#116 #0#157
ESC #27 #27 - -
F1 #0#59 #0#84 #0#94 #0#104
F2 #0#60 #0#85 #0#95 #0#105
F3 #0#61 #0#86 #0#96 #0#106
F4 #0#62 #0#87 #0#97 #0#107
F5 #0#63 #0#88 #0#98 #0#108
F6 #0#64 #0#89 #0#99 #0#109
F7 #0#65 #0#90 #0#100 #0#110
F8 #0#66 #0#91 #0#101 #0#111
F9 #0#67 #0#92 #0#102 #0#112
F10 #0#68 #0#93 #0#103 #0#113
F11 #0#133 #0#135 #0#137 #0#139
F12 #0#134 #0#136 #0#138 #0#140
Print Screen - - - -
Scroll Lock - - #3 -
PAUSE #0#12 #0#12 #3 #0#169
NUMPAD 0 #48 #0#82 - -
NUMPAD 1 #49 #0#79 - -
NUMPAD 2 #50 #0#80 - -
NUMPAD 3 #51 #0#81 - -
NUMPAD 4 #52 #0#75 - -
NUMPAD 5 #53 #0#76 - -
NUMPAD 6 #54 #0#77 - -
NUMPAD 7 #55 #0#71 - -
NUMPAD 8 #56 #0#72 - -
NUMPAD 9 #57 #0#73 - -
NUMPAD CLEAR #0#76 #0#76 #0#143 #0#76
NumLock - - - -
NUMPAD / #47 #47 #0#148 #0#69
NUMPAD * #42 #42 #0#149 #0#70
NUMPAD - #45 #45 #0#142 #0#74
NUMPAD + #43 #43 #0#144 #0#78
NUMPAD ENTER #13 #13 #10 #0#166
NUMPAD DECIMAL #46 #0#83 #0#150 #0#114

Procedure Sound(hz,dur:Word);

Cette procédure permet de générer des tonalités simples sur le haut-parleur. Le paramètre (hz) est la fréquence du son en hertz. Sa plage valide est comprise entre 37 et 32767. Le paramètre (dur) est la durée du son en millisecondes.

Procedure WriteBuf(buf:ShortString);

Cette procédure permet d'émuler la routine de console Write pour WinGraph. Il affiche à l'écran tous les caractères trouvés dans (buf), mais uniquement dans l'intervalle ' ' (espace) à '~' (tilde). Tous les autres caractères sont silencieusement ignorés. Le retour chariot (#13) est également reconnu. La routine utilise DefaultFont pour écrire les caractères horizontalement à l'écran et gérer elle-même le placement et les espaces intercaractères. Tous les autres styles de texte spécifiés par l'utilisateur sont pris en compte. Le texte est positionné à l'emplacement actuel du pixel. L'écran entier défile vers le haut si nécessaire. L'appel suivant WriteBuf place le texte sur la même ligne, sauf si un retour chariot est rencontré.

Routines WinMouse

L'unité WinMouse ajoute la prise en charge de la souris à WinGraph. La fenêtre graphique doit être activée avec InitGraph afin d'utiliser correctement cet unité.

Function GetMouseButtons:Word;

Cette fonction permet de retourner l'état actuel du bouton de la souris et l'état des touches Shift et Ctrl. Il peut s'agir d'une combinaison OR des constantes suivantes :

Constante Description
MouseLeftButton Le bouton gauche de la souris est maintenu enfoncé
MouseRightButton Le bouton droit de la souris est maintenu enfoncé
MouseMiddleButton Le bouton central de la souris est maintenu enfoncé
MouseShiftKey La touche Shift est maintenue enfoncée
MouseCtrlKey La touche Ctrl est maintenue enfoncée

Si aucun bouton ni touche n'est maintenu enfoncé, la fonction renvoie zéro.

Procedure GetMouseEvent(Out MouseEvent:MouseEventType);

Cette procédure permet de retourner le prochain événement de souris dans la file d'attente (mouvement, appui sur un bouton, relâchement d'un bouton ou défilement de la molette) et en attend un si aucun n'est disponible. Le champ (boutons) du paramètre (MouseEvent) est chargé avec les boutons de la souris, les touches Shift et Ctrl étant enfoncées pendant l'événement. Les champs (x), (y) entreposent la position de la souris, (molette) entrepose la rotation de la molette de la souris (par incrément de 120 pas, positif loin de l'utilisateur) et (action) entrepose l'événement. Il peut s'agir de l'une des constantes suivantes :

Constante Description
MouseActionDown Un bouton de la souris est enfoncé
MouseActionUp Un bouton de la souris est relâché
MouseActionMove Le curseur de la souris est déplacé
MouseActionWheel La molette de la souris tourne

La file d'attente des événements de la souris peut contenir plusieurs événements jusqu'à ce qu'ils soient récupérés.

Function GetMouseX:Word;

Cette fonction permet d'interroger la position horizontale actuelle du curseur de la souris. Cette position est mesurée en pixels, à partir de 0 sur le côté gauche de l'écran.

Function GetMouseY:Word;

Cette fonction permet d'interroger la position verticale actuelle du curseur de la souris. Cette position est mesurée en pixels, à partir de 0 en haut de l'écran.

Function GetMouseWheel:SmallInt;

Cette fonction permet d'interroger l'état de rotation de la molette de la souris (par incrément de 120 pas, positif loin de l'utilisateur). Il renvoie zéro si la roue n'est pas tournée. L'appel de cette routine une fois réinitialisera l'état de rotation de la roue à zéro.

Function PollMouseEvent(Out MouseEvent:MouseEventType):Boolean;

Cette fonction permet de vérifier si un événement de souris est disponible dans la file d'attente et le renvoie dans le paramètre (MouseEvent) s'il en trouve un. Le résultat de la fonction est True dans ce cas. Si aucun événement de souris n'est en attente, le résultat de la fonction est False et le contenu de (MouseEvent) est inchangé. Notez qu'après un appel à PollMouseEvent, l'événement doit toujours être supprimé de la file d'attente des événements de la souris avec un appel à GetMouseEvent.

Procedure PutMouseEvent(Const MouseEvent:MouseEventType);

Cette procédure permet d'ajouter (MouseEvent) à la file d'attente des événements de la souris. Cela peut être utilisé pour simuler un événement de souris.

Procedure SetMouseXY(x,y:Word);

Cette procédure permet de placer le curseur de la souris à la position (x,y). Il est mesuré en pixels, à partir de (0,0) à partir du coin supérieur gauche de l'écran.



Dernière mise à jour : Dimanche, le 9 juillet 2023