Fonctions graphiques

Pascal sur Macintosh (et sur Vax Berkeley par l'intermédiaire de l'émulateur terminal TGiX de Philippe Chassignet, cf Le manuel TGiX, version 2.2) donne la possibilité de faire très simplement des fonctions graphiques, grâce à une interface très simple avec la bibliothèque QuickDraw         du Macintosh. Sur Macintosh, une fenêtre Drawing permet de gérer un écran de points. L'origine du système de coordonnées est en haut et à gauche. L'axe des va classiquement de la gauche vers la droite, l'axe des va plus curieusement du haut vers le bas (c'est une vieille tradition de l'informatique, dure à remettre en cause). En QuickDraw, et sont souvent appelés h (horizontal) et v (vertical). Il y a une notion de point courant et de crayon avec une taille et une couleur courantes. On peut déplacer le crayon, en le levant ou en dessinant des vecteurs par les fonctions suivantes

MoveTo (x, y)

Déplace le crayon aux coordonnées absolues x, y.

Move (dx, dy)

Déplace le crayon en relatif de dx, dy.

LineTo (x, y)

Trace une ligne depuis le point courant jusqu'au point de coordonnées x, y.

Line (dx, dy)

Trace le vecteur (dx, dy) depuis le point courant.

PenPat(pattern)

Change la couleur du crayon: white, black, gray, dkGray (dark gray), ltGray (light gray).

PenSize(dx, dy)

Change la taille du crayon. La taille par défaut est (1, 1). Toutes les opérations de tracé peuvent se faire avec une certaine épaisseur du crayon.

PenMode(mode)

Change le mode d'écriture: patCopy (mode par défaut qui efface ce sur quoi on trace), patOr (mode Union, i.e. sans effacer ce sur quoi on trace), patXor (mode Xor, i.e. en inversant ce sur quoi on trace).

Certaines opérations sont possibles sur les rectangles. Un rectangle r a un type prédéfini Rect. Ce type est en fait un record qui a le format suivant

type
    VHSelect = (V, H);
    Point = record case indicateur of
            0: (v: integer;
                h: integer);
            1: (vh: array [VHSelect] of integer)
            end;

    Rect = record case indicateur of
           0: (top: integer;
               left: integer;
               bottom: integer;
               right: integer);
           1: (topLeft: Point;
               botRight: Point);
           end;

Fort heureusement, il n'y a pas besoin de connaître le format internes des rectangles, et on peut faire simplement les opérations graphiques suivantes sur les rectangles

SetRect(r, g, h, d, b)

fixe les coordonnées (gauche, haut, droite, bas) du rectangle r. C'est équivalent à faire les opérations r.left := g;, r.top := h;, r.right := d;, r.bottom := b.

UnionRect(r1, r2, r)

définit le rectangle r comme l'enveloppe englobante des rectangles r1 et r2.

FrameRect(r)

dessine le cadre du rectangle r avec la largeur, la couleur et le mode du crayon courant.

PaintRect(r)

remplit l'intérieur du rectangle r avec la couleur courante.

InvertRect(r)

inverse la couleur du rectangle r.

EraseRect(r)

efface le rectangle r.

FillRect(r,pat)

remplit l'intérieur du rectangle r avec la couleur pat.

 

DrawChar(c), DrawString(s)

affiche le caractère c ou la chaîne s au point courant dans la fenêtre graphique. Ces fonctions diffèrent de write ou writeln qui écrivent dans la fenêtre texte.

FrameOval(r)

dessine le cadre de l'ellipse inscrite dans le rectangle r avec la largeur, la couleur et le mode du crayon courant.

PaintOval(r)

remplit l'ellipse inscrite dans le rectangle r avec la couleur courante.

InvertOval(r)

inverse l'ellipse inscrite dans r.

EraseOval(r)

efface l'ellipse inscrite dans r.

FillOval(r,pat)

remplit l'intérieur l'ellipse inscrite dans r avec la couleur pat.

FrameArc(r,start,arc)

dessine l'arc de l'ellipse inscrite dans le rectangle r démarrant à l'angle start et sur la longueur définie par l'angle arc.

FrameArc(r,start,arc)

peint le camembert correspondant à l'arc précédent .... Il y a aussi des fonctions pour les rectangles avec des coins arrondis.

Button

est une fonction qui renvoie la valeur vraie si le bouton de la souris est enfoncé, faux sinon.

GetMouse(p)

renvoie dans p le point de coordonnées courantes du curseur.

GetPixel(p)

donne la couleur du point p. Répond un booléen: false si blanc, true. si noir.

HideCursor, ShowCursor

cache ou remontre le curseur.

  Dans le fichier <MacLib.h> du directory /usr/local/pascal/vax sur Vax, on trouve toutes les signatures des fonctiosn de QuickDraw, qui sont par ailleurs définies dans le document Inside The Macinstosh. Voici quelques exemples. La procédure suivante permet de lire les coordonnées d'un point, quand on appuie sur le bouton de la souris.

procedure GetXY (var x, y: integer);
    const N = 2;
    var r: Rect; p: Point;
    begin
    while not Button do   (* - *)
        ;
    GetMouse (p);         (* - *)
    x := p.h; y := p.v;
    SetRect (r, x-N, y-N, x+N, y+N);
    PaintOval (r);        (* On affiche le point pour signifier la lecture *)
    while Button do       (* - *)
        ;
    end;

Mais la lecture est souvent plus commode sur le front montant.

procedure GetXY (var x, y: integer);
    const N = 2;
    var r: Rect; p: Point;
    begin
    while not Button do   (* - *)
        ;
    while Button do       (* - *)
        ;
    GetMouse (p);         (* - *) 
    x := p.h; y := p.v;
    SetRect (r, x-N, y-N, x+N, y+N);
    PaintOval (r);        (* On affiche le point pour signifier la lecture *)
    end;

Un exemple plus amusant est le programme qui fait rebondir une balle dans un rectangle première étape vers un pong.

program Pong;
    const
        C = 5;               (* Le rayon de la balle *)
        X0 = 5; X1 = 250;
        Y0 = 5; Y1 = 180;
    var
        x, y, dx, dy: integer;
        r, s: Rect;
        i: integer;
    procedure GetXY (var x, y: integer);
        begin
        ...
        end;
begin
SetRect(s, 50, 50, X1 + 100, Y1 + 100);
SetDrawingRect(s);           (* - *)
ShowDrawing;                 (* - *)
SetRect(s, X0, Y0, X1, Y1);
FrameRect(s);                (* Le rectangle de jeu *)   
GetXY(x, y);                 (* - *)
dx := 1;                     (* La vitesse initiale *)
dy := 1;                     (* de la balle *)
while true do
    begin
    SetRect(r, x - C, y - C, x + C, y + C);
    PaintOval(r);            (* On dessine la balle en $x,y$ *)
    x := x + dx;
    if (x - C <= X0 + 1) or (x + C >= X1 - 1) then
        dx := -dx;
    y := y + dy;
    if (y - C <= Y0 + 1) or (y + C >= Y1 - 1) then
        dy := -dy;
    for i := 1 to 500 do
        ;                    (* On temporise *)
    InvertOval(r);           (* On efface la balle *)
    end;
end.