WGL (Workstation Graphics Library) Version 1.0 Yves Chartier Novembre 1990 Derniere mise a jour: 8 mars 1991 ------------------------------------------------------------------------------- Routines de WGL classees par categories ------------------------------------------------------------------------------- Conventions: WGL utilise deux espaces: un espace virtuel (ou physique), caracterise par des coordonnees de type reel, un espace pixel, caracterise par des coordonnees de type entier. Le scaling de base est fait selon les conventions suivantes: (xb,yb) (ib,jb) |------------| |------------| | | | | | espace | | espace | | virtuel | ---> | pixel | | | | | |------------| |------------| (xa,ya) (ia,ja) Le plus souvent, on aura (xb,yb) (isize-1,jsize-1) |------------| |------------| | | | | | espace | | espace | | virtuel | ---> | pixel | | | | | |------------| |------------| (xa,ya) (0, 0) ou isize et jsize sont les dimensions selon x et y d'une fenetre graphique. --------- Les routines ou fonctions se terminant par un "x" (ex. wgldrx) s'appliquent a l'espace virtuel. Les routines ou fonctions se terminant par un "i" (ex. wgldri) s'appliquent a l'espace pixel. Toute coordonnee commencant par x ou y est definie dans l'espace virtuel. Toute coordonnee commencant par i ou j est definie dans l'espace pixel. --------- Routines d'initialisation Deux routines doivent etre appelees pour initialiser WGL. Ces routines sont WGLOPW (c_wglopw) et WGLSSP (c_wglssp). Exemple FORTRAN: PROGRAM WGLTST #include EXTERNAL WGLOPW INTEGER WGLOPW INTEGER WINID WINID = WGLOPW('WGLTST') CALL WGLSSP(1.0, 1.0, 100.0, 100.0, 0, 0, 0, 0) C C ROUTINES DE DESSIN C CALL WGLCOL(BLEU) CALL WGLRFX(20.0, 20.0, 40.0, 50.0) ... STOP END Exemple C: #include main() { int winid; winid = c_wglopw("wgltest") c_wglssp(1.0, 1.0, 100.0, 100.0, 0, 0, 0, 0); /** Routines de dessin **/ c_wglcol(BLEU) c_wglrfx(20.0, 20.0, 40.0, 50.0); ... } Quelques exemples d'utilisation de WGL sont disponibles dans le repertoire ~armn025/src/wgldemos. --------- Utilisation de la librairie: Fichiers include: C: /home/cidsv02/armn/025/src/include/c_wgl.h FTN: /home/cidsv02/armn/025/src/include/wgl.h Destination: CYBER-910, mode graphique natif f77 -o objet objet.c -I/home/cidsv02/armn/025/src/include $ARMNLIB/lib/wgl_gl_910.a -lgl_s -lfm_s f77 -o objet objet.f -I/home/cidsv02/armn/025/src/include $ARMNLIB/lib/wgl_gl_910.a -lgl_s -lfm_s Destination: CYBER-910, X-Windows f77 -o objet objet.c -I/home/cidsv02/armn/025/src/include $ARMNLIB/lib/wgl_x_910.a -lXt -lX11 -lXext -lsun f77 -o objet objet.f -I/home/cidsv02/armn/025/src/include $ARMNLIB/lib/wgl_x_910.a -lXt -lX11 -lXext -lsun ------------------------------------------------------------------------------- ------------------------------------------------------------------------------- Scaling ------------------------------------------------------------------------------- SUBROUTINE WGLSSP(xa, ya, xb, yb, ia, ib, ja, jb) REAL xa, ya, xb, yb INTEGER ia, ib, ja, jb void c_wglssp(xa, ya, xb, yb, ia, ib, ja, jb) float xa, ya, xb, yb; int ia, ib, ja, jb; Objet: Etablit la correspondance entre l'espace virtuel ((xa,ya),(xb,yb)) et l'espace pixel ((ia, ja),(ib,jb)). Si les valeurs de ia, ja, ib et jb sont 0 (zero), la correspondance entre l'espace virtuel et l'espace pixel est faite sur la grandeur totale de la fenetre creee par l'appel a WGLOPW (c_wglopw). Il est a noter que dans ce cas, un aspect ratio de 1 pour 1 est force entre l'espace virtuel et l'espace pixel. Si les proportions de la fenetre ne sont pas les memes que celles de l'espace virtuel, l'espace virtuel ne remplira pas completement la fenetre. Par exemple, si on a ouvert une fenetre de dimension 800 x 800, et que l'on effectue les appels suivants: CALL WGLSSP(1.0, 1.0, 500.0, 250.0, 0, 0, 0, 0) CALL WGLCOL(BLANC) CALL WGLCLR CALL WGLCOL(NOIR) CALL WGLRFX(1.0, 1.0, 500.0, 250.0) on obtiendra le resultat suivant: ------------------------- - - - - - - - - ------------------------- ------------------------- ------------------------- ------------------------- ------------------------- ----------- ------------ SUBROUTINE WGLIAX(X, Y, i, j) REAL X, Y INTEGER I, J void c_wgliax(x, y, i, j) float *x, *y; int i, j; Objet: Etant donne un point (i,j) dans l'espace pixel, cette routine retourne le point correspondant (x,y) dans l'espace virtuel. ----------- ------------ SUBROUTINE WGLXAI(I, J, x, y) INTEGER I, J REAL X, Y void c_wglxai(i, j, x, y) int *i, *j; float x, y; Objet: Etant donne un point (x,y) dans l'espace virtuel, cette routine retourne le point correspondant (i,j) dans l'espace pixel. ----------- ------------ SUBROUTINE WGLGSP(XA, YA, XB, YB, IA, JA, IB, JB) REAL XA, YA, XB, YB INTEGER IA, JA, IB, JB void c_wglgsp(xa, ya, xb, yb, ia, ja, ib, jb) float *xa, *ya, *xb, *yb; int *ia, *ja, *ib, *jb; Memo: GSP (Get SPace espace virtuel et pixel) Objet: Retourne les coordonnees (xa,ya) et (xb,yb) definissant l'espace virtuel et les dimensions (ia,ja) et (ib,jb) definissant l'espace pixel. ----------- ------------ SUBROUTINE WGLGSI(IA, JA, IB, JB) INTEGER IA, JA, IB, JB void c_wglgsi(ia, ja, ib, jb) int *ia, *ja, *ib, *jb; Memo: GSI (Get Space espace pixel) Objet: Retourne les coordonnees (ia,ja), (ib,jb) definissant l'espace pixel. ----------- ------------ SUBROUTINE WGLGSX(XA, YA, XB, YB) REAL XA, YA, XB, YB void c_wglgsx(xa, ya, xb, yb) float *xa, *ya, *xb, *yb; Memo: GSX (Get Space espace virtuel) Objet: Retourne les coordonnees (xa,ya), (xb,yb) definissant l'espace virtuel. ----------- ------------ SUBROUTINE WGLGZP(XSIZE, YSIZE, ISIZE, JSIZE) REAL XSIZE, YSIZE INTEGER ISIZE, YSIZE void c_wglgzp(xsize, ysize, isize, jsize) float *xsize, *ysize; int *isize, *jsize; Memo: GZP (Get siZe espace virtuel et pixel) Objet: Retourne les dimensions (xsize, ysize) de l'espace virtuel et les dimensions (isize, jsize) de l'espace pixel. ----------- ------------ SUBROUTINE WGLGZI(ISIZE, JSIZE) INTEGER ISIZE, JSIZE void c_wglgzi(isize, jsize); integer *isize, *jsize; Memo: GZI (Get siZe espace pixel) Objet: Retourne les dimensions (isize, jsize) de l'espace pixel. ----------- ------------ SUBROUTINE WGLGZX(XSIZE, YSIZE) REAL XSIZE, YSIZE void c_wglgzx(xsize, ysize) float *xsize, *ysize; Memo: GZX (Get siZe espace virtuel) Objet: Retourne les dimensions (xsize, ysize) de l'espace virtuel. ----------- ------------ SUBROUTINE WGLGVP(XA, YA, XB, YB, IA, JA, IB, JB) REAL XA, YA, XB, YB INTEGER IA, JA, IB, JB void c_wglgvp(xa, ya, xb, yb, ia, ja, ib, jb) float *xa, *ya, *xb, *yb; int *ia, *ib, *ja, *jb; Memo: GVP (Get Visible space espace virtuel et pixel) Objet: Retourne la partie visible des espaces virtuel et pixel. ----------- ------------ SUBROUTINE WGLGVI(IA, JA, IB, JB) INTEGER IA, JA, IB, JB void c_wglgvi(ia, ja, ib, jb) int *ia, *ib, *ja, *jb; Memo: GVI (Get Visible space espace pixel) Objet: Retourne la partie visible de l'espace pixel. ----------- ------------ SUBROUTINE WGLGVX(XA, YA, XB, YB) REAL XA, YA, XB, YB void c_wglgvx(xa, ya, xb, yb) float *xa, *ya, *xb, *yb; Memo: GVX (Get Visible space espace virtuel) Objet: Retourne la partie visible de l'espace physique. Le point (xa,ya) represente le coin inferieur gauche de l'espace physique, le point (xb,yb), le coin superieur droit. ----------- ------------ ------------------------------------------------------------------------------- Figures geometriques ------------------------------------------------------------------------------- ----------------------------------------- - Arcs de cercle - ----------------------------------------- SUBROUTINE WGLALX(x, y, rayon, angdeb, angfin) REAL x, y, rayon, angdeb, angfin void c_wglalx(x, y, rayon, angdeb, angfin) float x, y, rayon, angdeb, angfin; Memo: ALX (Arc de cercle - Line - espace virtuel) Objet: Trace un arc de cercle de dimension "rayon", centre au point (x,y), dont le perimetre s'etend de "angdeb" a "angfin", dans le sens contraire des aiguilles d'une montre. "rayon" est defini en unites de l'espace virtuel. Les angles sont definis en degres. L'angle 0 est a 03 heures. ----------- ------------ SUBROUTINE WGLALI(i, j, irayon, angdeb, angfin) INTEGER i, j, irayon REAL angdeb, angfin void c_wglali(i, j, irayon, angdeb, angfin) int i, j, irayon; float angdeb, angfin; Memo: ALI (Arc de cercle - Line - espace pixel) Objet: Trace un arc de cercle de dimension "irayon", centre au point (i,j), dont le perimetre s'etend de "angdeb" a "angfin", dans le sens contraire des aiguilles d'une montre. "irayon" est defini en pixels. Les angles sont definis en degres. L'angle 0 est a 03 heures. ----------- ------------ SUBROUTINE WGLAFX(x, y, rayon, angdeb, angfin) REAL x, y, rayon, angdeb, angfin void c_wglafx(x, y, rayon, angdeb, angfin) float x, y, rayon, angdeb, angfin; Memo: AFX (Arc de cercle - Fill - espace virtuel) Objet: Remplit un arc de cercle de dimension "rayon", centre au point (x,y), dont le perimetre s'etend de "angdeb" a "angfin", dans le sens contraire des aiguilles d'une montre. "rayon" est defini en unites virtuelles. Les angles sont definis en degres. L'angle 0 est a 03 heures. ----------- ------------ SUBROUTINE WGLAFI(i, j, irayon, angdeb, angfin) INTEGER i, j, irayon REAL angdeb, angfin void c_wglafi(i, j, irayon, angdeb, angfin) int i, j, irayon; float angdeb, angfin; Memo: AFI (Arc de cercle - Fill - espace pixel) Objet: Remplit un arc de cercle de dimension "irayon", centre au point (i,j), dont le perimetre s'etend de "angdeb" a "angfin", dans le sens contraire des aiguilles d'une montre. "irayon" est defini en pixels. Les angles sont definis en degres. L'angle 0 est a 03 heures. ------------------------------------------------------------------------------- ----------------------------------------- - Cercles - ----------------------------------------- SUBROUTINE WGLCLX(x, y, rayon) REAL x, y, rayon void c_wglclx(x, y, rayon) float x, y, rayon; Memo: CLX (Cercle - Line - espace virtuel) Objet: Trace un cercle de dimension "rayon", centre au point (x,y). "rayon" est defini en unites de l'espace virtuel. ----------- ------------ SUBROUTINE WGLCLI(i, j, irayon) INTEGER i, j, irayon void c_wglcli(i, j, irayon) int i, j, irayon; Memo: CLI (Cercle - Line - espace pixel) Objet: Trace un cercle de dimension "irayon", centre au point (i,j). "irayon" est defini en pixels. ----------- ------------ SUBROUTINE WGLCFX(x, y, rayon) REAL x, y, rayon void c_wglcfx(x, y, rayon) float x, y, rayon; Memo: CFX (Cercle - Fill - espace virtuel) Objet: Remplit un cercle de dimension "rayon", centre au point (x,y). "rayon" est defini en unites virtuelles. ----------- ------------ SUBROUTINE WGLCFI(i, j, irayon) INTEGER i, j, irayon void c_wglcfi(i, j, irayon) int i, j, irayon; Memo: CFI (Cercle - Fill - espace pixel) Objet: Remplit un cercle de dimension "irayon", centre au point (i,j). "irayon" est defini en pixels. ------------------------------------------------------------------------------- ----------------------------------------- - Points - ----------------------------------------- SUBROUTINE WGLPTX(x, y) REAL x, y void c_wglptx(x, y) float x, y; Memo: PTX (PoinT espace virtuel) Objet: Affiche un pixel a la position (x,y). ----------- ------------ SUBROUTINE WGLPTI(i, j) INTEGER i, j void c_wglpti(i, j) int i, j; Memo: PTI (PoinT espace pixel) Objet: Affiche un pixel a la position (i,j). ------------------------------------------------------------------------------- ----------------------------------------- - Lignes - ----------------------------------------- SUBROUTINE WGLMVX(x, y) REAL x, y void c_wglmvx(x, y) float x, y; Memo: MVX (MoVe espace virtuel) Objet: Deplace la position graphique courante a la position (x,y), et specifie la position du premier point d'une ligne. ----------- ------------ SUBROUTINE WGLMVI(i, j) INTEGER i, j void c_wglmvi(i, j) int i, j; Memo: MVI (MoVe espace pixel) Objet: Deplace la position graphique courante a la position (i,j), et specifie la position du premier point d'une ligne. ----------- ------------ SUBROUTINE WGLDRX(x, y) REAL x, y void c_wgldrx(x, y) float x, y; Memo: DRX (DRaw espace virtuel) Objet: Trace un segment de droite entre la position graphique courante et la position (x,y). La position (x,y) devient la nouvelle position graphique courante apres l'execution de la routine. ----------- ------------ SUBROUTINE WGLDRI(i, j) INTEGER i, j void c_wgldri(i, j) int i, j; Memo: DRI (DRaw espace pixel) Objet: Trace un segment de droite entre la position graphique courante et la position (i,j). La position (i,j) devient la nouvelle position graphique courante apres l'execution de la routine. ------------------------------------------------------------------------------- ----------------------------------------- - Rectangles - ----------------------------------------- SUBROUTINE WGLRLX(xleft, ybottm, xright, ytop) REAL xleft, ybottm, xright, ytop void c_wglrlx(xleft, ybottm, xright, ytop) float xleft, ybottm, xright, ytop; Memo: RLX (Rectangle - Line - mode virtuel) Objet: Trace un rectangle defini par les coordonnees (xleft,ybottm) et (xright,ytop). ----------- ------------ SUBROUTINE WGLRLI(ileft, jbottm, iright, jtop) INTEGER ileft, jbottm, iright, jtop void c_wglrli(ileft, jbottm, iright, jtop) int ileft, jbottm, iright, jtop; Memo: RLI (Rectangle - Line - mode pixel) Objet: Trace un rectangle defini par les coordonnees (ileft, jbottm) et (iright, jtop). ----------- ------------ SUBROUTINE WGLRFX(xleft, ybottm, xright, ytop) REAL xleft, ybottm, xright, ytop void c_wglrlx(xleft, ybottm, xright, ytop) float xleft, ybottm, xright, ytop; Memo: RFX (Rectangle - Fill - mode virtuel) Objet: Remplit un rectangle defini par les coordonnees (xleft,ybottm) et (xright,ytop). ----------- ------------ SUBROUTINE WGLRFI(ileft, jbottm, iright, jtop) INTEGER ileft, jbottm, iright, jtop void c_wglrfi(ileft, jbottm, iright, jtop) int ileft, jbottm, iright, jtop; Memo: RFI (Rectangle - Fill - mode pixel) Objet: Remplit un rectangle defini par les coordonnees (ileft, jbottm) et (iright, jtop). ------------------------------------------------------------------------------- ----------------------------------------- - Polygones - ----------------------------------------- SUBROUTINE WGLPLX(npts, p) INTEGER npts REAL p(2, npts) void c_wglplx(npts, p) int npts; float p[][2]; Memo: PLX (Polygone - Line - espace virtuel) Objet: Trace le polygone (p(1,1), p(2,1))... (p(1,npts)(2,npts)) (FORTRAN). Trace le polygone (p[0][0],p[0][1])...(p[npts-1][0],p[npts-1][1]) (C). Chacune des coordonnees correspond a des positions definies dans l'espace virtuel. L'implementation courante suppose que le polygone est convexe. ----------- ------------ SUBROUTINE WGLPLI(npts, p) INTEGER npts INTEGER p(2, npts) void c_wglpli(npts, p) int npts; int p[][2]; Memo: PLI (Polygone - Line - espace pixel) Objet: Trace le polygone (p(1,1),p(2,1))... (p(1,npts),(2,npts)) (FORTRAN). Trace le polygone (p[0][0],p[0][1])...(p[npts-1][0],p[npts-1][1]) (C). Chacune des coordonnees correspond a des positions definies dans l'espace pixel. L'implementation courante suppose que le polygone est convexe. ----------- ------------ SUBROUTINE WGLPFX(npts, p) INTEGER npts REAL p(2, npts) void c_wglpfx(npts, p) int npts; float p[][2]; Memo: PFX (Polygone - Fill - espace virtuel) Objet: Remplit le polygone (p(1,1),p(2,1))... (p(1,npts),(2,npts)) (FORTRAN). Remplit le polygone (p[0][0],p[0][1])...(p[npts-1][0],p[npts-1][1])(C). Chacune des coordonnees correspond a des positions definies dans l'espace virtuel. L'implementation courante suppose que le polygone est convexe. ----------- ------------ SUBROUTINE WGLPFI(npts, p) INTEGER npts INTEGER p(2, npts) void c_wglpfi(npts, p) int p[][2]; int npts; Memo: PFI (Polygone - Fill - espace pixel) Objet: Remplit le polygone (p(1,1), p(2,1))... (p(1,npts),(2,npts))(FORTRAN). Remplit le polygone (p[0][0],p[0][1])...(p[npts-1][0],p[npts-1][1])(C). Chacune des coordonnees correspond a des positions definies dans l'espace pixel. L'implementation courante suppose que le polygone est convexe. ----------- ------------ ------------------------------------------------------------------------------- ------------------------------------------------------------------------------- ----------------------------------------- - Chaines de caracteres - ----------------------------------------- ********* Notes generales: L'implementation des routines affichant les chaines de caracteres est presentement incomplete. L'interface des routines decrites ici devrait cependant rester stable. Le tracage des chaines de caracteres se fait dans la couleur courante. La police de caracteres choisie est "Times-Roman". Il est possible que cette police ne soit pas disponible sur toutes les stations de travail ou les terminaux X. Dans cette eventualite, la police "fixed" sera alors choisie. Les conventions suivantes s'appliquent: La position (x,y) ou (i,j) utilisee pour l'affichage d'une chaine de caracteres est montree par le diese. La ligne de base correspond a la position verticale du diese; les parties ascendantes et descendantes se retrouvent de chaque cote de la ligne de base. La taille d'une police est definie en points (ou pixels). ********* * | * | * | * | **** **** | * * * * | * * * * | * * * * | partie ascendante (ascent) * * * * | ========#==*=====****============ ligne de base (baseline) * | * | partie descendante (descent) * | ********* SUBROUTINE WGLFSZ(size) INTEGER size void c_wglfsz(size) int size; Memo: FSZ (Font SiZe) Objet: Regle la taille de la police (en pixels). Les valeurs de "size" sont presentement restreintes a 10, 12, 14, 17, 18 et 24 points. ----------- ------------ SUBROUTINE WGLPSX(x, y, chr, nchr, size, anot, icent) REAL x, y CHARACTER *(*) chr INTEGER nchr, size, anot, icent void c_wglpsx(x, y, chr, nchr, size, anot, icent) float x, y; char chr[]; int nchr, size, anot, icent; Memo: PSX (Plot String - espace virtuel) Objet: Affiche "nchr" caracteres de la chaine "chr" a la position x,y de l'espace virtuel. Les valeurs de "size" sont presentement restreintes a 10, 12, 14, 17, 18 et 24 points. Un appel a WGLFSZ (c_wglfsz) est effectue si la taille de la police est differente de celle utilisee lors du dernier appel a WGLPS(X,I) c_wglps(x,i). Les valeurs de "anot" et "icent" sont presentement sans effet. ----------- ------------ SUBROUTINE WGLPSI(i, j, chr, nchr, size, anot, icent) INTEGER i,j CHARACTER *(*) chr INTEGER nchr, size, anot, icent void c_wglpsi(i, j, chr, nchr, size, anot, icent) int i,j; char chr[]; int nchr, size, anot, icent; Memo: PSI (Plot String - espace pixel) Objet: Affiche "nchr" caracteres de la chaine "chr" a la position i,j de l'espace pixel. Les valeurs de "size" sont presentement restreintes a 10, 12, 14, 17, 18 et 24 points. Un appel a WGLFSZ (c_wglfsz) est effectue si la taille de la police est differente de celle utilisee lors du dernier appel a WGLPS(X,I) c_wglps(x,i). Les valeurs de "anot" et "icent" sont presentement sans effet. ----------- ------------ REAL FUNCTION WGLWSX(chr, nchr) CHARACTER *(*) chr INTEGER nchr float c_wglwsx(chr, nchr) char chr[]; int nchr; Memo: WSX (Width of String - espace virtuel) Objet: Retourne la largeur (en coordonnees virtuelles) des "nchr" caracteres de la chaine "chr", pour la taille courante de la police. ----------- ------------ INTEGER FUNCTION WGLWSI(chr, nchr) CHARACTER *(*) chr INTEGER nchr int c_wglwsi(chr, nchr) char chr[]; int nchr; Memo: WSI (Width of String - espace pixel) Objet: Retourne la largeur (en pixels) des "nchr" caracteres de la chaine "chr", pour la taille courante de la police. ----------- ------------ REAL FUNCTION WGLASX(chr, nchr) CHARACTER *(*) chr INTEGER nchr float c_wglasx(chr, nchr) char chr[]; int nchr; Memo: ASX (Ascent of String - espace virtuel) Objet: Retourne la hauteur de la partie ascendante (en coordonnees virtuelles) des "nchr" caracteres de la chaine "chr", pour la taille courante de la police. ----------- ------------ INTEGER FUNCTION WGLASI(chr, nchr) CHARACTER *(*) chr INTEGER nchr int c_wglasi(chr, nchr) char chr[]; int nchr; Memo: WSI (Width of String - espace pixel) Objet: Retourne la hauteur de la partie ascendante (en pixels) des "nchr" caracteres de la chaine "chr", pour la taille courante de la police. ----------- ------------ REAL FUNCTION WGLDSX(chr, nchr) CHARACTER *(*) chr INTEGER nchr float c_wgldsx(chr, nchr) char chr[]; int nchr; Memo: DSX (Descent of String - espace virtuel) Objet: Retourne la hauteur de la partie descendante (en coordonnees virtuelles) des "nchr" caracteres de la chaine "chr", pour la taille courante de la police. ----------- ------------ INTEGER FUNCTION WGLDSI(chr, nchr) CHARACTER *(*) chr INTEGER nchr int c_wgldsi(chr, nchr) char chr[]; int nchr; Memo: DSI (Descent of String - espace pixel) Objet: Retourne la hauteur de la partie descendante (en pixels) des "nchr" caracteres de la chaine "chr", pour la taille courante de la police. ------------------------------------------------------------------------------- Options graphiques ------------------------------------------------------------------------------- ----------------------------------------- - Lignes et patrons - ----------------------------------------- SUBROUTINE WGLLWI(width) INTEGER width void c_wgllwi(width) int width; Memo: LWI (LineWIdth) Objet: Definit la largeur (en pixels) des lignes utilisees pour l'affichage des lignes, rectangles, polygones, cercles et arcs de cercle. ----------- ------------ INTEGER FUNCTION WGLGLW int c_wglglw() Memo: GLW (Get Line Width) Objet: Retourne la largeur (en pixels) des lignes utilisees pour l'affichage des lignes, rectangles, polygones, cercles et arcs de cercle. ----------- ------------ SUBROUTINE WGLDLD(inddsh, ipatrn) INTEGER inddsh, ipatrn void c_wgldld(inddsh, ipatrn) int inddsh, ipatrn; Memo: DLD (Define Line Dash pattern index) Objet: Definit un patron de 16 bits utilise pour le trace de lignes tiretees. "inddsh" est l'indice du patron, et peut varier de -127 a 127. "ipatrn" contient la definition du patron, de la gauche vers la droite. L'indice 0 contient une ligne pleine (patron Z'ffff'(FTN), 0xffff(C)), et ne peut etre redefini. Voici quelques exemples de tiretes (FORTRAN, C): ---------------- Z'f0f0',0xf0f0: **** **** Z'8888',0x8888: * * * * Z'3333',0x3333: ** ** ** ** Z'5050',0x5050: * * * * Cette routine ne fait que definir un indice de patron. Pour appliquer cet indice sur l'affichage de figures geometriques, il faut appeler la routine "WGLSLD" ou "c_wglsld". ----------- ------------ SUBROUTINE WGLSLD(inddsh) INTEGER inddsh void c_wglsld(inddsh) int inddsh Memo: SLD (Set Line Dash index) Objet: Remplace l'indice de tirete courant par "inddsh". ----------- ------------ INTEGER FUNCTION WGLGLD int c_wglgld() Memo: GLD (Get Line Dash index) Objet: Retourne l'indice de tirete courant. ----------- ------------ SUBROUTINE WGLDPT(indpat, ipatsz, ipatrn) INTEGER indpat, ipatsz INTEGER*2 ((ipatsz*ipatsz)/16) void c_wgldpt(indpat, ipatsz, ipatrn) int indpat, ipatsz, ipatrn; Memo: DPT (Define PaTtern index) Objet: Definit un patron de "ipatsz" bits utilise pour la definition de patrons. "ipatsz" peut prendre la valeur 16 ou 32. "inddsh" est l'indice du patron, et peut varier de -127 a 127. "ipatrn" contient la definition du patron. Le patron est defini du bas vers le haut, de la gauche vers la droite. Le patron 0 contient un patron plein et ne peut etre redefini. Voici un exemple de patron 16 bits (sur cet exemple, les bits marques d'une asterisque sont colores, les autres sont transparents): ---------------- FTN: Z'3333',Z'3333',Z'CCCC',Z'CCCC',Z'3333',Z'3333',Z'CCCC',Z'CCCC' Z'3333',Z'3333',Z'CCCC',Z'CCCC',Z'3333',Z'3333',Z'CCCC',Z'CCCC' C: 0x3333 ,0x3333, 0xCCCC ,0xCCCC, 0x3333, 0x3333, 0xCCCC, 0xCCCC 0x3333 ,0x3333, 0xCCCC ,0xCCCC, 0x3333, 0x3333, 0xCCCC, 0xCCCC ------------------ |** ** ** ** | |** ** ** ** | | ** ** ** **| | ** ** ** **| |** ** ** ** | |** ** ** ** | | ** ** ** **| | ** ** ** **| |** ** ** ** | |** ** ** ** | | ** ** ** **| | ** ** ** **| |** ** ** ** | |** ** ** ** | | ** ** ** **| | ** ** ** **| ------------------ Cette routine ne fait que definir un indice de patron. Pour appliquer cet indice sur l'affichage de figures geometriques, il faut appeler la routine "WGLSPT" ou "c_wglspt". ----------- ------------ SUBROUTINE WGLSPT(indpat) INTEGER indpat void c_wglspt(indpat) int indpat; Memo: SPT (Set PaTtern index) Objet: Remplace l'indice de patron courant par "indpat". ----------- ------------ INTEGER FUNCTION WGLGPT int c_wglgpt() Memo: GPT (Get PaTtern index) Objet: Retourne l'indice de patron courant. ----------- ------------ INTEGER FUNCTION WGLLPT int c_wgllpt() Memo: LPT (Load PaTterns) Objet: Charge en memoire les patrons de defauts utilises par CMC-RPN. Retourne une valeur >= 0 si tout va bien. Retourne une valeur < 0 si un probleme a ete rencontre. Dans ce cas on suppose que les patrons n'ont pas ete charges correctement. ------------------------------------------------------------------------------- ----------------------------------------- - Couleurs - ----------------------------------------- Dans sa version actuelle, WGL permet l'utilisation d'une table de 256 couleurs, dont les 32 premieres sont reservees et ne peuvent pas etre redefinies par l'usager. Les huit premieres couleurs de la table sont conformes a la palette de defaut du CALCOMP. Le mapping des couleurs de base est le suivant: Indice Couleur 0 BLANC 1 NOIR 2 ROUGE 3 CYAN 4 JAUNE 5 MAGNTA 6 VERT 7 BLEU Ces parametres sont definis dans le fichier "include" "wgl.h" (pour FORTRAN) et "c_wgl.h" (pour C) ----------- ------------ SUBROUTINE WGLNCL(NCOLST, NCOLAN) INTEGER NCOLST, NCOLAN int c_wglncl(ncolst, ncolan) int *ncolst, *ncolan; Memo: NCL (Nombre de CouLeurs) Objet: Retourne le nombre de couleurs disponibles, en mode standard, de meme qu'en mode animation. Cette fonction retourne normalement les valeurs (256, 256). La seule exception concerne la version GL de WGL pour les CYBER-910 qui n'ont que 8 plans de couleurs. Dans ce cas cette routine retourne les valeurs (256, 16). ----------- ------------ SUBROUTINE WGLMCO(indcol, red, green, blue) INTEGER indcol, red, green, blue void c_wglmco(indcol, red, green, blue) int indcol, red, green, blue; Memo: MCO (MapColor) Objet: Associe un triplet (red,green,blue) a un indice de la table de couleurs. La valeur de "indcol" doit etre comprise entre 32 et 255. La valeur de chacun des elements du triplet doit etre comprise entre 0 et 255. ----------- ------------ SUBROUTINE WGLGCO(indcol, RED, GREEN, BLUE) INTEGER indcol, RED, GREEN, BLUE void c_wglgco(indcol, red, green, blue) int indcol; int *red, *green, *blue; Memo: GCO (Get COlor) Objet: Retourne les valeurs du triplet (red,green,blue) associes a l'indice "indcol" de la table de couleurs. La valeur de "indcol" doit etre comprise entre 0 et 255. ----------- ------------ INTEGER FUNCTION WGLGCI int c_wglgci Memo: GCI (Get ColorIndex) Objet: Retourne l'indice courant de la table de couleurs utilise pour tracer des objets. ----------- ------------ SUBROUTINE WGLCOL(indcol) INTEGER indcol void c_wglcol(indcol) int indcol; Memo: COL (set COLor index) Objet: Remplace l'indice courant de la table de couleur par "indcol". Tous les objets traces apres un appel a WGLCOL se font dans la couleur definie par "indcol". La valeur de "indcol" doit etre comprise entre 0 et 255. ----------- ------------ SUBROUTINE WGLDCM void c_wgldcm() Memo: DCM (Default ColorMap) Objet: Remplace la table de couleur courante par la table de defaut. ----------- ------------ SUBROUTINE WGLSMK(masque) INTEGER masque; void c_wglsmk(masque) int masque; Memo: SMK (Set MasK) Objet: Definit un masque de protection pour les bitplanes. ----------- ------------ SUBROUTINE WGLGMK int c_wglgmk() Memo: GMK (Get MasK) Objet: Retourne le masque de protection couramment utilise pour proteger les bitplanes. ----------- ------------ ------------------------------------------------------------------------------- Fenetres ------------------------------------------------------------------------------- INTEGER FUNCTION WGLOPW(winttl) CHARACTER *(*) winttl int c_wglopw(winttl) char *winttl; Memo: OPW (OPen Window) Objet: Ouvre une fenetre dans laquelle on pourra dessiner. L'argument "winttl" sera utilise pour identifier la fenetre. ----------- ------------ SUBROUTINE WGLCLW(winid) INTEGER winid int c_wglclw(winid) int winid; Memo: CLW (CLose Window) Objet: Ferme la fenetre de dessin ayant l'identificateur "winid". ----------- ------------ SUBROUTINE WGLCLR void c_wglclr() Memo: CLR (CLeaR) Objet: Effacer la fenetre d'affichage courante, dans la couleur specifiee par le dernier appel a WGLCOL (c_wglcol). ----------- ------------ SUBROUTINE WGLKAS(iasp, jasp) INTEGER iasp, jasp; void c_wglkas(iasp, jasp) int iasp, jasp; Memo: KAS (Keep ASpect ratio) Objet: Permet de specifier l'aspect ratio d'une fenetre (iasp / jasp) que l'on desire ouvrir. Cette routine doit etre appelee avant WGLOPW (c_wglopw) pour etre effective. ----------- ------------ SUBROUTINE WGLFSC void c_wglfsc() Memo: FSC (Full SCreen) Objet: Permet d'ouvrir une fenetre qui remplira tout l'ecran. Cette routine doit etre appelee avant WGLOPW (c_wglopw) pour etre effective. ----------- ------------ SUBROUTINE WGLPPO(i1, j1, isize, jsize) INTEGER i1, j1, isize, jsize void c_wglppo(i1, j1, isize, jsize) int i1, j1, isize, jsize; Memo: PPO (Preferred POsition) Objet: Permet de specifier la position du coin inferieur gauche, de meme que les dimensions (largeur, hauteur) d'une fenetre que l'on desire ouvrir. Cette routine doit etre appelee avant WGLOPW (c_wglopw) pour etre effective. ----------- ------------ SUBROUTINE WGLPSZ(isize, jsize) INTEGER isize, jsize void c_wglpsz(isize, jsize) int isize, jsize; Memo: PSZ (Preferred SiZe) Objet: Permet de specifier la grandeur d'une fenetre que l'on desire ouvrir. Cette routine doit etre appelee avant WGLOPW (c_wglopw) pour etre effective. ----------- ------------ ------------------------------------------------------------------------------- Animation ------------------------------------------------------------------------------- SUBROUTINE WGLDBF void c_wgldbf() Memo: DBF (Double BuFfer) Objet: Met la station de travail en mode "doublebuffer". Dans ce mode, les routines tracant des figures geometriques peuvent dessiner dans une fenetre virtuelle ou dans la fenetre de dessin courante. Le choix de la fenetre se fait par l'appel des routines WGLFBF (c_wglfbf) et WGLBBF (c_wglbbf). Sur les CYBER-910 qui n'ont que 8 plans de couleurs, cette fonction reduit le nombre de couleurs disponibles de 256 a 16. ----------- ------------ SUBROUTINE WGLSBF void c_wglsbf() Memo: SBF (Single BuFfer) Objet: Ramene la station de travail a son mode de defaut. Dans ce mode, les routines tracant des figures geometriques sont limitees a la fenetre de dessin courante. Sur les CYBER-910 qui n'ont que 8 plans de couleurs, cette fonction restitue le nombre de couleurs disponibles de 16 a 256. ----------- ------------ SUBROUTINE WGLFBF void c_wglfbf() Memo: FBF (Front BuFfer) Objet: Lorsque la station est en mode "doublebuffer", cette routine regle la fenetre de destination a la fenetre de dessin courante. ----------- ------------ SUBROUTINE WGLBBF void c_wglbbf() Memo: BBF (Back BuFfer) Objet: Lorsque la station est en mode "doublebuffer", cette routine regle la fenetre de destination a la fenetre virtuelle. ----------- ------------ LOGICAL FUNCTION WGLGBF Boolean c_wglgbf() Memo: GBF (Get BuFfer) Objet: Retourne le mode d'animation courant FALSE: singlebuffer TRUE : doublebuffer ----------- ------------ SUBROUTINE WGLSWB void c_wglswb() Memo: SWB (SWap Buffers) Objet: Remplace l'image de la fenetre de dessin courante par celle conservee dans la fenetre virtuelle. ----------- ------------ Ex. d'animation, interrompu lorsque le bouton gauche de la souris a ete clique. Ex. FORTRAN: CALL WGLDBF CALL WGLBBF 100 CONTINUE ... (routines de dessin) ... CALL WGLSWB IF (.FALSE..EQ.WGLBTP(BGAUCH)) THEN GOTO 100 ENDIF CALL WGLFBF ... (routines de dessin) ... Ex. C c_wgldbf(); c_wglbbf(); while (!(c_wglbtp(BGAUCH))) { ... (routines de dessin) ... c_wglswb(); } c_wglfbf(); ... (routines de dessin) ... ------------------------------------------------------------------------------- Manipulation de la souris ------------------------------------------------------------------------------- Dans les fonctions qui vont suivre, la variable bouton peut prendre les valeurs suivantes: BGAUCH: bouton gauche BMLIEU: bouton du milieu BDROIT: bouton droit BTOUS : les 3 boutons Ces valeurs sont definies dans les fichiers include "wgl.h" (FORTRAN) et "c_wgl.h" (C). ----------- ------------ LOGICAL FUNCTION WGLBTN(bouton) INTEGER BOUTON; Boolean c_wglbtn(bouton) int bouton; Memo: BTN (BouToN) Objet: Attend un clic du bouton de la souris specifie par "bouton". FALSE: Un bouton autre que "bouton" a ete clique. TRUE : Le bouton "bouton" a ete clique. Cette fonction peut etre utilisee pour marquer une pause a la fin de l'affichage d'un ensemble de figures. Ex. 1 ------ FORTRAN: 100 CONTINUE IF (.FALSE..EQ.WGLBTN(BGAUCH)) THEN GOTO 100 ENDIF C: while (!(c_wglbtn(BGAUCH))); Ex. 2 ------ FORTRAN: RES = WGLBTN(BTOUS) C: c_wglbtn(BTOUS); ----------- ------------ LOGICAL FUNCTION WGLBTP(bouton) INTEGER BOUTON Boolean c_wglbtp(bouton) int bouton; Memo: BTP (BouTon mode Poll) Objet: Permet de determiner instantanement le statut d'un bouton de la souris FALSE: bouton leve TRUE : bouton presse Cette fonction peut etre utilisee dans une boucle d'animation, qui perdure jusqu'a ce que le bouton de la souris ait ete appuye. A noter que la fonction WGLBTN (c_wglbtn) ne pourrait etre utilisee a cette fin, puisque cette derniere ne revient au module qui l'a appelee que lorsqu'un des boutons de la souris a ete appuye. ----------- ------------ INTEGER FUNCTION WGLBTI(I, J) INTEGER I, J int c_wglbti(i, j) int *i, *j; Memo: BTI (BouTon - espace pixel) Objet: Attend un clic d'un des boutons de la souris et retourne l'indice du bouton clique, de meme que la position (i,j) du clic dans la fenetre. Exemple FORTRAN: INTEGER I, J, BOUTON; INTEGER FUNCTION WGLBTI BOUTON = WGLBTI(I,J) IF (BOUTON.EQ.BGAUCH) THEN PRINT *,'LE BOUTON GAUCHE A ETE CLIQUE AU PT (I,J)=(',I,',',J,')' ELSE IF (BOUTON.EQ.BMLIEU) PRINT *,'LE BOUTON DU MILIEU A ETE CLIQUE AU PT (I,J)=(',I,',',J,')' ELSE IF (BOUTON.EQ.BDROIT) PRINT *,'LE BOUTON DROIT A ETE CLIQUE AU PT (I,J)=(',I,',',J,')' ENDIF Exemple C: int i, j, bouton; bouton = c_wglbti(&i, &j); switch (bouton) { case BGAUCH: printf("Le bouton gauche a ete clique au pt(i,j)=(%d,%d)\n",i,j); break; case BMLIEU: printf("Le bouton du milieu a ete clique au pt(i,j)=(%d,%d)\n",i,j); break; case BDROIT: printf("Le bouton droit a ete clique au pt(i,j)=(%d,%d)\n",i,j); break; } ----------- ------------ INTEGER FUNCTION WGLBTX(X, Y) REAL X, Y int c_wglbtx(x, y) float *x, *y; Memo: BTX (BouTon - espace virtuel) Objet: Attend un clic d'un des boutons de la souris et retourne l'indice du bouton clique, de meme que la position (x,y) du clic dans la fenetre. L'exemple cite pour la fonction WGLBTI (c_wglbti) peut s'appliquer tout aussi bien pour cette fonction. ----------- ------------ Index alphabetique de WGL ------------------------- wglafi - Affichage d'arcs de cercles pleins wglafx - Affichage d'arcs de cercles pleins wglali - Affichage d'arcs de cercles vides wglalx - Affichage d'arcs de cercles vides wglasi - Retour de la hauteur de la partie ascendante d'une chaine de caracteres (en pixels) wglasx - Retour de la hauteur de la partie ascendante d'une chaine de caracteres courante (en coordonnees virtuelles) wglbbf - Activation de la fenetre d'affichage virtuelle (back buffer) wglbti - Attente d'un clic de la souris, retour de la position i,j du clic wglbtn - Attente d'un clic de la souris wglbtp - Attente d'un clic de la souris (polling) wglbtx - Attente d'un clic de la souris, retour de la position x,y du clic wglcfi - Cercles pleins wglcfx - Cercles pleins wglcli - Cercles vides wglclr - Effacement de la fenetre wglclx - Cercles vides wglclw - Fermeture de la fenetre wglcol - Modification de l'indice courant de la table de couleurs wgldbf - Active le mode animation wgldcm - Ajustement de la table de couleurs a son etat initial wgldld - Definition de patrons de tiretes wgldpt - Definition de patrons de motifs wgldri - Tracage de lignes wgldrx - Tracage de lignes wgldsi - Retour de la taille de la partie descendante d'une chaine de caracteres (en pixels) wgldsx - Retour de la taille de la partie descendante d'une chaine de caracteres (en coordonnees virtuelles) wglfbf - Activation de la fenetre d'affichage reelle (front buffer) wglfsc - Ouverture de la fenetre en mode fullscreen wglfsz - Modification de la taille de la police utilisee pour le tracage des chaines de caracteres wglgbf - Retour du mode d'animation courant (actif ou inactif) wglgci - Retour de l'indice de la table de couleurs couramment utilise wglgco - Retour des valeurs (r,g,b) d'un indice de la table de couleurs wglgld - Retour de l'indice de patrons de tiretes courant wglglw - Retour de la largeur courante du pinceau wglgmk - Retour du masque courant utilise pour les plans de couleurs wglgpt - Retour de l'indice de patrons de motifs courant wglgsi - Retour des coordonnees definissant l'espace pixel wglgsp - Retour des coordonnees definissant l'espace pixel et virtuel wglgsx - Retour des coordonnees definissant l'espace virtuel wglgvi - Retour des coordonnees definissant l'espace pixel visible wglgvp - Retour des coordonnees definissant l'espace pixel et virtuel visible wglgvx - Retour des coordonnees definissant l'espace pixel et virtuel visible wglgwz - Retour des dimensions de la fenetre wglgzi - Retour des dimensions de l'espace pixel wglgzp - Retour des dimensions de l'espace pixel et virtuel wglgzx - Retour des dimensions de l'espace virtuel wglkas - Specification de l'aspect-ratio de la fenetre wgliax - Retour de la position dans l'espace pixel d'un point dans l'espace virtuel wgllpt - Chargement de la table de patrons utilises par les utilitaires de NCAR wgllwi - Modification de la taille du pinceau wglmco - Modification des valeurs (r,g,b) d'un indice de la table de couleurs wglmvi - Deplacement du pinceau dans l'espace pixel wglmvx - Deplacement du pinceau dans l'espace virtuel wglncl - Retour du nombre de couleurs disponibles en mode d'affichage normal et en mode animation wglopw - Ouverture de la fenetre de dessin wglpfi - Tracage de polygones pleins, espace pixel wglpfx - Tracage de polygones pleins, espace reel wglpli - Tracage de polygones vides, espace pixel wglplx - Tracage de polygones vides, espace reel wglppo - Specification de la position sur l'ecran de la fenetre d'affichage wglpsz - Specification des dimensions sur l'ecran de la fenetre d'affichage wglpti - Affichage de points, espace pixel wglptx - Affichage de points, espace virtuel wglrfi - Affichage de rectangles pleins, espace pixel wglrfx - Affichage de rectangles pleins, espace virtuel wglrli - Affichage de rectangles vides, espace pixel wglrlx - Affichage de rectangles vides, espace virtuel wglsbf - Desactivation de la fenetre d'affichage virtuelle wglsld - Modification de l'indice courant utilise pour le tracage de tiretes wglsmk - Modification du masque de plans de couleurs courant wglssp - Etablissement de la correspondance entre l'espace virtuel et l'espace pixel wglspt - Modification de l'indice courant utilise pour le tracage de motifs wglswb - Remplacement du contenu de la fenetre reelle par celui de la fenetre virtuelle wglwsi - Retour de la largeur d'une chaine de caracteres (en pixels) wglwsx - Retour de la largeur d'une chaine de caracteres (en coordonnees virtuelles) wglxai - Retour des coordonnees dans l'espace virtuel d'un point defini dans l'espace pixel