/*
* inc/gks_type.h
* Include file with high level type definitions for GKS - compilation order
* Microsoft C 5.0 - Turbo C 2.0 - VAX C 3.0
* Grupo de Tecnologia em Computacao Grafica - PUC/RIO
* 23 Ago 91
*/

#ifndef _GKS_TYPE_
#define _GKS_TYPE_

/****                ****/
/*   Type declaration   */
/****                ****/

/** Enumerating types **/

/* Gacf - attribute control flag */
   typedef enum {
         CURRENT,
         SPECIFIED
   } Gacf;
/* Gasf - aspect source flag */
   typedef enum {
         BUNDLED,
         INDIVIDUAL
   } Gasf;
/* Gattrs - attributes used */
   typedef enum {
         POLYLINE,
         POLYMARKER,
         TEXT,
         FILLAREA
   } Gattrs;
/* Gbis - bundle index setting */
   typedef enum {
         DEFINED,
         UNDEFINED
   } Gbis;
/* Gclip - clipping indicator */
   typedef enum {
         CLIP,
         NOCLIP
   } Gclip;
/* Gclrflag - clear control flag */
   typedef enum {
         CONDITIONALLY,
         ALWAYS
   } Gclrflag;
/* Gcoavail - colour availability */
   typedef enum {
         COLOUR,
         MONOCHROME
   } Gcoavail;
/* Gcovalid - colour values valid */
   typedef enum {
         ABSENT,
         PRESENT
   } Gcovalid;
/* Gcstat - choice status */
   typedef enum {
         C_OK,
         C_NOCHOICE,
         C_NONE
   } Gcstat;
/* Gcsw - coordinate switch */
   typedef enum {
         WC,   /* world coordinates */
         NDC   /* normalized device coordinates */
   } Gcsw;
/* Gdefmode - deferral mode */
   typedef enum {
         ASAP, /* as soon as possible */
         BNIG, /* before next interaction globaly */
         BNIL, /* before next interaction localy */
         ASTI  /* at some time */
   } Gdefmode;
/* Gdevunits - device coordinate unit */
   typedef enum {
         DC_METRES,
         DC_OTHER
   } Gdevunits;
/* Gdspsurf - display surface */
   typedef enum {
         EMPTY,
         NOTEMPTY
   } Gdspsurf;
/* Gesw - echo switch */
   typedef enum {
         ES_ECHO,
         ES_NOECHO
   } Gesw;
/* Gflinter - fill area interior style */
   typedef enum {
         HOLLOW,
         SOLID,
         PATTERN,
         HATCH
   } Gflinter;
/* Giclass - input class */
   typedef enum {
         I_NONE,
         I_LOCATOR,
         I_STROKE,
         I_VALUATOR,
         I_CHOICE,
         I_PICK,
         I_STRING
   } Giclass;
/* Gimode - input mode */
   typedef enum {
         REQUEST,
         SAMPLE,
         EVENT
   } Gimode;
/* Girgmode - implicit regeneration mode */
   typedef enum {
         SUPPRESSED,
         ALLOWED
   } Girgmode;
/* Gistat - request status */
   typedef enum {
         OK,
         NONE
   } Gistat;
/* Glastev - last event */
   typedef enum {
         LAST,
         NOTLAST
   } Glastev;
/* Gmodtype - dynamic modification type */
   typedef enum {
         IRG,
         IMM
   } Gmodtype;
/* Gnframe - new frame action at update */
   typedef enum {
         NO,
         YES
   } Gnframe;
/* Gos - GKS operating state */
   typedef enum {
         GKCL, /* GKS closed */
         GKOP, /* GKS open */
         WSOP, /* workstation open */
         WSAC, /* workstation active */
         SGOP  /* segment open */
   } Gos;
/* Gpfcf - polyline/fill area control flag */
   typedef enum {
         PF_POLYLINE,
         PF_FILLAREA
   } Gpfcf;
/* Gpstat - pick status */
   typedef enum {
         P_OK,
         P_NOPICK,
         P_NONE
   } Gpstat;
/* Gqtype - inquire type */
   typedef enum {
         SET,
         REALIZED
   } Gqtype;
/* Gregen - regeneration flag */
   typedef enum {
         PERFORM,
         POSTPONE
   } Gregen;
/* Gsegdet - segment detectability */
   typedef enum {
         UNDETECTABLE,
         DETECTABLE
   } Gsegdet;
/* Gseghi - segment highlighting */
   typedef enum {
         NORMAL,
         HIGHLIGHTED
   } Gseghi;
/* Gsegvis - segment visibility */
   typedef enum {
         VISIBLE,
         INVISIBLE
   } Gsegvis;
/* Gsimultev - simultaneous events */
   typedef enum {
         NOMORE,
         MORE
   } Gsimultev;
/* Gtoggle - toggle switch */
   typedef enum {
         OFF,
         ON
   } Gtoggle;
/* Gtxhor - text alignment horizontal component */
   typedef enum {
         TH_NORMAL,
         TH_LEFT,
         TH_CENTRE,
         TH_RIGHT
   } Gtxhor;
/* Gtxpath - text path */
   typedef enum {
         TP_RIGHT,
         TP_LEFT,
         TP_UP,
         TP_DOWN
   } Gtxpath;
/* Gtxprec - text precision */
   typedef enum {
         STRING,
         CHAR,
         STROKE
   } Gtxprec;
/* Gtxver - text alignment vertical component */
   typedef enum {
         TV_NORMAL,
         TV_TOP,
         TV_CAP,
         TV_HALF,
         TV_BASE,
         TV_BOTTOM
   } Gtxver;
/* Gvpri - viewport input priority */
   typedef enum {
         HIGHER,
         LOWER
   } Gvpri;
/* Gwscat - workstation category */
   typedef enum {
         OUTPUT,
         INPUT,
         OUTIN,
         WISS,
         MO,
         MI
   } Gwscat;
/* Gwsclass - workstation classification */
   typedef enum {
         VECTOR,
         RASTER,
         OTHER
   } Gwsclass;
/* Gwsstate - workstation state */
   typedef enum {
         INACTIVE,
         ACTIVE
   } Gwsstate;
/* Gwstus - workstation transformation update state */
   typedef enum {
         NOTPENDING,
         PENDING
   } Gwstus;

/** direct derivated types **/

/* Gchar - character (8 bits minimum) */
   typedef unsigned char Gchar;
/* Gerror - default return value type */
   typedef int Gerror;
/* Gfloat - floating point number (single precision minimum) */
   typedef float Gfloat;
/* Gint - integer (16 bits minimum) */
   typedef int Gint;
/* Glong - long integer (32 bits minimum) */
   typedef long Glong;

/** indirect derivated types **/

/* Gchrexp - character expansion factor */
   typedef Gfloat Gchrexp;
/* Gchrsp - character spacing */
   typedef Gfloat Gchrsp;
/* Gcolour - colour index */
   typedef Gint Gcolour;
/* Gdc - device coordinates */
   typedef Gfloat Gdc;
/* Gflstyle - fill area style index */
   typedef Gint Gflstyle;
/* Gidevno - input device number (no == number) */
   typedef Gint Gidevno;
/* Gindex - bundle index */
   typedef Gint Gindex;
/* Ginten - colour intensity */
   typedef Gfloat Ginten;
/* Glntype - line type */
   typedef Gint Glntype;
/* Gmktype - marker type */
   typedef Gint Gmktype;
/* Gndc - normalized device coordinates */
   typedef Gfloat Gndc;
/* Gpet - prompt and echo type */
   typedef Gint Gpet;
/* Gpickid - pick identifier */
   typedef Gint Gpickid;
/* Gscale - scale factor */
   typedef Gfloat Gscale;
/* Gseg - segment */
   typedef Gint Gseg;   /* contiguous integers >= 1 */
/* Gsegpri - segment priority */
   typedef Gfloat Gsegpri;
/* Gtxfont - text font */
   typedef Gint Gtxfont;
/* Gwc - world coordinates */
   typedef Gfloat Gwc;
/* Gws - workstation */
   typedef Gint Gws;

/* Gchrht - character height */
   typedef Gwc Gchrht;
/* Gchrwid - character width */
   typedef Gwc Gchrwid;

/** compost types **/

/* Gasfs - aspect source flags */
   typedef struct {
         Gasf ln_type;     /* line type */
         Gasf ln_width;    /* line width */
         Gasf ln_colour;   /* line colour */
         Gasf mk_type;     /* marker type */
         Gasf mk_size;     /* marker size */
         Gasf mk_colour;   /* marker colour */
         Gasf tx_fp;       /* text font and precision */
         Gasf tx_exp;      /* text expansion */
         Gasf tx_space;    /* text character spacing */
         Gasf tx_colour;   /* text colour */
         Gasf fl_inter;    /* fill area interior style */
         Gasf fl_style;    /* fill area style index */
         Gasf fl_colour;   /* fill area colour */
   } Gasfs;
/* Gbii - bundle index information */
   typedef struct {
         Gint  number;  /* number of bundles */
         Gbis *defined; /* defined bundles */
   } Gbii;
/* Gchoicerec - choice data record */
   typedef union {
         struct {
                Gchar    *data;     /* device/implementation dependent data */
         } pet1;
         struct {
                Gint      number;   /* number of alternatives */
                Gtoggle  *enable;   /* array of prompts */
                Gchar    *data;     /* device/implementation dependent data */
         } pet2;
         struct {
                Gint      number;   /* number of choice strings */
                Gchar   **strings;  /* array of strings */
                Gchar    *data;     /* device/implementation dependent data */
         } pet3;
         struct {
                Gint      number;   /* number of choice strings */
                Gchar   **strings;  /* array of strings */
                Gchar    *data;     /* device/implementation dependent data */
         } pet4;
         struct {
                Gseg      seg;      /* segment name */
                Gint      number;   /* number of alternatives */
                Gpickid  *pickids;  /* array of pick identifiers */
                Gchar    *data;     /* device/implementation dependent data */
         } pet5;
         /* ...                        more for implementation defined PETs */
   } Gchoicerec;
/* Gcobundl - colour bundle */
   typedef struct {
         Ginten red;    /* red intensity */
         Ginten green;  /* green intensity */
         Ginten blue;   /* blue intensity */
   } Gcobundl;
/* Gcofac - colour facilities */
   typedef struct {
         Gint     colours;    /* number of colours */
         Gcoavail coavail;    /* colour availability */
         Gint     predefined; /* number of predefined bundles */
   } Gcofac;
/* Gdefer - deferral state */
   typedef struct {
         Gdefmode defmode; /* deferral mode */
         Girgmode irgmode; /* implicit regeneration mode */
   } Gdefer;
/* Gdlimit - device coordinate limits */
   typedef struct {
         Gdc xmin;   /* x minimum limit */
         Gdc xmax;   /* x maximum limit */
         Gdc ymin;   /* y minimum limit */
         Gdc ymax;   /* y maximum limit */
   } Gdlimit;
/* Gdpoint - device coordinate point */
   typedef struct {
         Gdc x;   /* x coordinate */
         Gdc y;   /* y coordinate */
   } Gdpoint;
/* Gdrect - device coordinate rectangle */
   typedef struct {
         Gdpoint ll; /* lower left-hand corner */
         Gdpoint ur; /* upper right-hand corner */
   } Gdrect;
/* Gescin - escape input data record */
   typedef union {
         struct {
                Gchar   *data;   /* escape dependent data record */
         } escid1;               /* name of the specified escape function */
         struct {
                Gchar   *data;   /* escape dependent data record */
         } escid2;               /* name of the specified escape function */
         /* ...                     more for implementation defined PETs */
   } Gescin;
/* Gescout - escape output data record */
   typedef union {
         struct {
                Gchar   *data;   /* escape dependent data record */
         } escid1;               /* name of the specified escape function */
         struct {
                Gchar   *data;   /* escape dependent data record */
         } escid2;               /* name of the specified escape function */
         /* ...                     more for implementation defined PETs */
   } Gescout;
/* Gevent - event */
   typedef struct {
         Gws     ws;    /* workstation */
         Gidevno dev;   /* device number */
         Giclass class; /* event class */
   } Gevent;
/* Gflbundl - fill area bundle */
   typedef struct {
         Gflinter inter;   /* fill area interior style */
         Gflstyle style;   /* fill area style index */
         Gcolour  colour;  /* fill area colour index */
   } Gflbundl;
/* Gflfac - fill area facilities */
   typedef struct {
         Gint  n_inter;    /* number of interior styles */
         Gint *interiors;  /* list of available interior styles */
         Gint  n_hatch;    /* number of hatch styles */
         Gint *hatches;    /* list of available hatch styles */
         Gint  predefined; /* number of predefined bundles */
   } Gflfac;
/* Ggdpfac - GDP facilities */
   typedef struct {
         Gint    number;   /* number of GDPs */
         Gattrs *attrs;    /* list of attributes used */
   } Ggdpfac;
/* Ggdprec - GDP data record */
   typedef union {
         struct {
                Gchar   *data;   /* GDP dependent data record */
         } gdpid1;               /* name of the specified GDP function */
         struct {
                Gchar   *data;   /* GDP dependent data record */
         } gdpid2;               /* name of the specified GDP function */
         /* ...                     more for implementation defined PETs */
   } Ggdprec;
/* Ggksmit - GKS metafile item */
   typedef struct {
         Gint type;     /* item type */
         Gint length;   /* item length */
   } Ggksmit;
/* Gipoint - integer point */
   typedef struct {
         Gint x; /* x coordinate */
         Gint y; /* y coordinate */
   } Gipoint;
/* Glnbundl - polyline bundle */
   typedef struct {
         Glntype type;     /* line type */
         Gscale  width;    /* linewidth scale factor */
         Gcolour colour;   /* polyline colour index */
   } Glnbundl;
/* Glnfac - polyline facilities */
   typedef struct {
         Gint  types;      /* number of line types */
         Gint *list;       /* list of available line types */
         Gint  widths;     /* number of line widths */
         Gdc   nom;        /* nominal width */
         Gdc   min;        /* minimum width */
         Gdc   max;        /* maximum width */
         Gint  predefined; /* number of predefined bundles */
   } Glnfac;
/* Gmkbundl - polymarker bundle */
   typedef struct {
         Gmktype type;     /* marker type */
         Gscale  size;     /* marker size scale */
         Gcolour colour;   /* polymarker colour index */
   } Gmkbundl;
/* Gmkfac - polymarker facilities */
   typedef struct {
         Gint  types;      /* number of marker types */
         Gint *list;       /* list of available marker types */
         Gint  sizes;      /* number of marker sizes */
         Gdc   nom;        /* nominal size */
         Gdc   min;        /* minimum size */
         Gdc   max;        /* maximum size */
         Gint  predefined; /* number of predefined bundles */
   } Gmkfac;
/* Gmodseg - dynamic modification for segment attributes */
   typedef struct {
         Gmodtype transform;  /* transformation */
         Gmodtype appear;     /* appearing (turning visible) */
         Gmodtype disappear;  /* disappearing (turning invisible) */
         Gmodtype highlight;  /* highlighting */
         Gmodtype priority;   /* priority */
         Gmodtype addition;   /* addition of primitives to segment */
         Gmodtype deletion;   /* deletion of segment */
   } Gmodseg;
/* Gmodws - dynamic modification of workstation attributes */
   typedef struct {
         Gmodtype line;    /* polyline */
         Gmodtype mark;    /* polymarker */
         Gmodtype text;    /* text */
         Gmodtype fill;    /* fill area */
         Gmodtype pat;     /* pattern */
         Gmodtype colour;  /* colour */
         Gmodtype wstran;  /* workstation transformation */
   } Gmodws;
/* Gnlimit - normalized device coordinate limits */
   typedef struct {
         Gndc xmin;  /* x minimum limit */
         Gndc xmax;  /* x maximum limit */
         Gndc ymin;  /* y minimum limit */
         Gndc ymax;  /* y maximum limit */
   } Gnlimit;
/* Gnpoint - normalized device coordinate point */
   typedef struct {
         Gndc x;  /* x coordinate */
         Gndc y;  /* y coordinate */
   } Gnpoint;
/* Gnrect - normalized device coordinate rectangle */
   typedef struct {
         Gnpoint ll; /* lower left-hand corner */
         Gnpoint ur; /* upper right-hand corner */
   } Gnrect;
/* Gnumdev - number of input devices */
   typedef struct {
         Gint locator;  /* locators */
         Gint stroke;   /* strokes */
         Gint valuator; /* valuators */
         Gint choice;   /* choices */
         Gint pick;     /* picks */
         Gint string;   /* strings */
   } Gnumdev;
/* Gpick - pick data */
   typedef struct {
      Gpstat   status;  /* pick status */
      Gseg     seg;     /* pick segment */
      Gpickid  pickid;  /* pick identifier */
   } Gpick;
/* Gpickrec - pick data record */
   typedef union {
         struct {
                Gchar *data;  /* device/implementation dependent data */
         } pet1;
         struct {
                Gchar *data;  /* device/implementation dependent data */
         } pet2;
         struct {
                Gchar *data;  /* device/implementation dependent data */
         } pet3;
         /* ...                  more for implementation defined PETs */
   } Gpickrec;
/* Gpickst - pick state */
   typedef struct {
         Gimode   mode;    /* mode */
         Gesw     esw;     /* echo switch */
         Gpick    pick;    /* pick data */
         Gpet     pet;     /* prompt and echo type */
         Gdlimit  e_area;  /* echo area */
         Gpickrec record;  /* pick data record */
   } Gpickst;
/* Gptbundl - pattern bundle */
   typedef struct {
         Gipoint  size;    /* pattern array size */
         Gcolour *array;   /* pattern array */
   } Gptbundl;
/* Gptfac - pattern facilities */
   typedef struct {
         Gint types;       /* number of pattern types */
         Gint predefined;  /* number of predefined bundles */
   } Gptfac;
/* Gpxarray - pixel array */
   typedef struct {
         Gcovalid  covalid;   /* colour values valid */
         Gcolour  *array;     /* pixel array */
   } Gpxarray;
/* Gqchoice - request choice */
   typedef struct {
         Gcstat status; /* request status */
         Gint   choice; /* choice data */
   } Gqchoice;
/* Gqpick - request pick */
   typedef struct {
         Gpstat  status;   /* request status */
         Gseg    seg;      /* segment */
         Gpickid pickid;   /* pick identifier */
   } Gqpick;
/* Gqstring - request string */
   typedef struct {
         Gistat  status;   /* request status */
         Gchar  *string;   /* string data */
   } Gqstring;
/* Gqval - request valuator */
   typedef struct {
         Gistat status; /* request status */
         Gfloat val;    /* valuator data */
   } Gqval;
/* Gsegtran - segment transformation */
   typedef struct {
         Gfloat m11; /* matrix element 1, 1 */
         Gfloat m12; /* matrix element 1, 2 */
         Gndc   m13; /* matrix element 1, 3 */
         Gfloat m21; /* matrix element 2, 1 */
         Gfloat m22; /* matrix element 2, 2 */
         Gndc   m23; /* matrix element 2, 3 */
   } Gsegtran;
/* Gstringrec - string data record */
   typedef union {
         struct {
                Gint   bufsiz;   /* buffer size */
                Gint   position; /* initial cursor position */
                Gchar *data;     /* device/implementation dependent data */
         } pet1;
         /* ...                     more for implementation defined PETs */
   } Gstringrec;
/* Gstringst - string state */
   typedef struct {
         Gimode      mode;    /* mode */
         Gesw        esw;     /* echo switch */
         Gchar      *string;  /* string data */
         Gpet        pet;     /* prompt and echo type */
         Gdlimit     e_area;  /* echo area */
         Gstringrec  record;  /* string data record */
   } Gstringst;
/* Gtxalign - text alignment */
   typedef struct {
         Gtxhor hor; /* horizontal component */
         Gtxver ver; /* vertical component */
   } Gtxalign;
/* Gtxfp - text font and precision */
   typedef struct {
         Gtxfont font;  /* text font */
         Gtxprec prec;  /* text precision */
   } Gtxfp;
/* Gvalrec - valuator data record */
   typedef union {
         struct {
                Gfloat  low;  /* low range limit */
                Gfloat  high; /* high range limit */
                Gchar  *data; /* device/implementation dependent data */
         } pet1;
         struct {
                Gfloat  low;  /* low range limit */
                Gfloat  high; /* high range limit */
                Gchar  *data; /* device/implementation dependent data */
         } pet2;
         struct {
                Gfloat  low;  /* low range limit */
                Gfloat  high; /* high range limit */
                Gchar  *data; /* device/implementation dependent data */
         } pet3;
         /* ...                  more for implementation defined PETs */
   } Gvalrec;
/* Gvalst - valuator state */
   typedef struct {
         Gimode  mode;     /* mode */
         Gesw    esw;      /* echo switch */
         Gfloat  val;      /* valuator data */
         Gpet    pet;      /* prompt and echo type */
         Gdlimit e_area;   /* echo area */
         Gvalrec record;   /* stroke data record */
   } Gvalst;
/* Gwlimit - world coordinate limits */
   typedef struct {
         Gwc xmin;   /* x minimum limit */
         Gwc xmax;   /* x maximum limit */
         Gwc ymin;   /* y minimum limit */
         Gwc ymax;   /* y maximum limit */
   } Gwlimit;
/* Gwpoint - world coordinate point */
   typedef struct {
         Gwc x;   /* x coordinate */
         Gwc y;   /* y coordinate */
   } Gwpoint;
/* Gwrect - world coordinate rectangle */
   typedef struct {
         Gwpoint ll; /* lower left-hand corner */
         Gwpoint ur; /* upper right-hand corner */
   } Gwrect;
/* Gwsct - workstation connection and type */
   typedef struct {
         Gchar *conn;   /* workstation connection */
         Gchar *type;   /* workstation type */
   } Gwsct;
/* Gwsdus - workstation deferral and update state */
   typedef struct {
         Gdefmode defmode; /* deferral mode */
         Gdspsurf dspsurf; /* display surface */
         Girgmode irgmode; /* implicit regeneration mode */
         Gnframe  nframe;  /* new frame action at update */
   } Gwsdus;
/* Gwsmax - workstation maximum numbers */
   typedef struct {
         Gint open;     /* number of open workstations */
         Gint active;   /* number of active workstations */
         Gint assoc;    /* number of associated workstations */
   } Gwsmax;
/* Gwstables - length of workstation tables */
   typedef struct {
         Gint line;     /* polyline tables */
         Gint mark;     /* polymarker tables */
         Gint text;     /* text tables */
         Gint fill;     /* fill area tables */
         Gint pat;      /* pattern tables */
         Gint colour;   /* colour tables */
   } Gwstables;
/* Gwstran - workstation transformation */
   typedef struct {
         Gnlimit w;  /* window */
         Gdlimit v;  /* viewport */
   } Gwstran;

/** declaration order dependent types **/

/* Gchoicest - choice state */
   typedef struct {
         Gimode     mode;     /* mode */
         Gesw       esw;      /* echo switch */
         Gint       choice;   /* choice data */
         Gpet       pet;      /* prompt and echo type */
         Gdlimit    e_area;   /* echo area */
         Gchoicerec record;   /*choice data record */
   } Gchoicest;
/* Gcliprec - clipping rectangle */
   typedef struct {
         Gclip   ind;   /* clipping indicator */
         Gnlimit rec;   /* clipping rectangle */
   } Gcliprec;
/* Gdefchoice - default choice data */
   typedef struct {
      Gint        choices; /* maximum number of choices */
      Gint        n_pets;  /* number of prompt and echo types */
      Gpet       *pets;    /* list of prompt and echo types */
      Gdlimit     e_area;  /* default echo area */
      Gchoicerec  record;  /* default choice data record */
   } Gdefchoice;
/* Gdefpick - default pick data */
   typedef struct {
         Gint      n_pets; /* number of prompt and echo types */
         Gpet     *pets;   /* list of prompt and echo types */
         Gdlimit   e_area; /* default echo area */
         Gpickrec  record; /* default pick data record */
   } Gdefpick;
/* Gdefstring - default string data */
   typedef struct {
         Gint        bufsiz;  /* initial buffer size */
         Gint        n_pets;  /* number of prompt and echo types */
         Gpet       *pets;    /* list of prompt and echo types */
         Gdlimit     e_area;  /* default echo area */
         Gstringrec  record;  /* default string data record */
   } Gdefstring;
/* Gdefval - default valuator data */
   typedef struct {
         Gfloat   value;   /* initial value */
         Gint     n_pets;  /* number of prompt and echo types */
         Gpet    *pets;    /* list of prompt and echo types */
         Gdlimit  e_area;  /* default echo area */
         Gvalrec  record;  /* default valuator data record */
   } Gdefval;
/* Gdspsize - display size */
   typedef struct {
         Gdevunits units;  /* device coordinate units */
         Gdpoint   device; /* device coordinate unit size */
         Gipoint   raster; /* raster unit size */
   } Gdspsize;
/* Gextent - text extent */
   typedef struct {
         Gwpoint concat;   /* concatenation point */
         Gwpoint ll;       /* lower left corner */
         Gwpoint lr;       /* lower right corner */
         Gwpoint ur;       /* upper right corner */
         Gwpoint ul;       /* upper left corner */
   } Gextent;
/* Gflattr - fill area attributes */
   typedef struct {
         Gasf     fl_inter;   /* fill area interior style ASF */
         Gasf     fl_style;   /* fill area style index ASF */
         Gasf     fl_colour;  /* fill area colour ASF */
         Gindex   fill;       /* fill area index */
         Gflbundl flbundl;    /* fill area bundle */
   } Gflattr;
/* Glnattr - polyline attributes */
   typedef struct {
         Gasf     ln_type;    /* linetype ASF */
         Gasf     ln_width;   /* linewidth ASF */
         Gasf     ln_colour;  /* linecolour ASF */
         Gindex   line;       /* line index */
         Glnbundl lnbundl;    /* line bundle */
   } Glnattr;
/* Gloc - locator data */
   typedef struct {
         Gint    transform;   /* normalization transformation number */
         Gwpoint position;    /* locator position */
   } Gloc;
/* Glocrec - locator data record */
   typedef union {
         struct {
                Gchar   *data;   /* device/implementation dependent data */
         } pet1;
         struct {
                Gchar   *data;   /* device/implementation dependent data */
         } pet2;
         struct {
                Gchar   *data;   /* device/implementation dependent data */
         } pet3;
         struct {
                Gacf     acf;    /* attribute control flag */
                Glnattr  ln;     /* polyline attributes */
                Gchar   *data;   /* device/implementation dependent data */
         } pet4;
         struct {
                Gpfcf    pfcf;   /* polyline/fill area control flag */
                Gacf     acf;    /* attribute control flag */
                union {
                      Glnattr ln; /* polyline attributes */
                      Gflattr fl; /* fill area attributes */
                } attr;
                Gchar   *data;   /* device/implementation dependent data */
         } pet5;
         struct {
                Gchar   *data;   /* device/implementation dependent data */
         } pet6;
         /* ...                     more for implementation defined PETs */
   } Glocrec;
/* Glocst - locator state */
   typedef struct {
         Gimode  mode;     /* mode */
         Gesw    esw;      /* echo switch */
         Gloc    loc;      /* locator data */
         Gpet    pet;      /* prompt and echo type */
         Gdlimit e_area;   /* echo area */
         Glocrec record;   /* locator data record */
   } Glocst;
/* Gmkattr - polymarker attributes */
   typedef struct {
         Gasf     mk_type;    /* marker type ASF */
         Gasf     mk_size;    /* marker width ASF */
         Gasf     mk_colour;  /* marker colour ASF */
         Gindex   mark;       /* marker index */
         Gmkbundl mkbundl;    /* marker bundle */
   } Gmkattr;
/* Gqloc - request locator */
   typedef struct {
         Gistat status; /* request status */
         Gloc   loc;    /* locator data */
   } Gqloc;
/* Gstroke - stroke data */
   typedef struct {
         Gint     transform;  /* normalization transformation number */
         Gint     n_points;   /* number of points in stroke */
         Gwpoint *points;     /* points in stroke */
   } Gstroke;
/* Gstrokerec - stroke data record */
   typedef union {
         struct {
                Gint     bufsiz;    /* input buffer size */
                Gint     editpos;   /* editing position */
                Gwpoint  interval;  /* x, y interval */
                Gfloat   time;      /* time interval */
                Gchar   *data;      /* device/implementation dependent data */
         } pet1;
         struct {
                Gint     bufsiz;    /* input buffer size */
                Gint     editpos;   /* editing position */
                Gwpoint  interval;  /* x, y interval */
                Gfloat   time;      /* time interval */
                Gchar   *data;      /* device/implementation dependent data */
         } pet2;
         struct {
                Gint     bufsiz;    /* input buffer size */
                Gint     editpos;   /* editing position */
                Gwpoint  interval;  /* x, y interval */
                Gfloat   time;      /* time interval */
                Gacf     acf;       /* attribute control flag */
                Gmkattr  mk;        /* marker attributes */
                Gchar   *data;      /* device/implementation dependent data */
         } pet3;
         struct {
                Gint     bufsiz;    /* input buffer size */
                Gint     editpos;   /* editing position */
                Gwpoint  interval;  /* x, y interval */
                Gfloat   time;      /* time interval */
                Gacf     acf;       /* attribute control flag */
                Glnattr  ln;        /* line attributes */
                Gchar   *data;      /* device/implementation dependent data */
         } pet4;
         /* ...                        more for implementation defined PETs */
   } Gstrokerec;
/* Gstrokest - stroke state */
   typedef struct {
         Gimode     mode;     /* mode */
         Gesw       esw;      /* echo switch */
         Gstroke    stroke;   /* stroke data */
         Gpet       pet;      /* prompt and echo type */
         Gdlimit    e_area;   /* echo area */
         Gstrokerec record;   /* stroke data record */
   } Gstrokest;
/* Gtxbundl - text bundle */
   typedef struct {
         Gtxfp   fp;       /* font and precision */
         Gchrexp exp;      /* character expansion */
         Gchrsp  space;    /* character spacing */
         Gcolour colour;   /* text colour */
   } Gtxbundl;
/* Gtxfac - text facilities */
   typedef struct {
         Gint   fps;          /* number of fonts and precisions */
         Gtxfp *fp_list;      /* list of available fonts and precisions */
         Gint   heights;      /* number of character heights */
         Gdc    min_ht;       /* minimum height */
         Gdc    max_ht;       /* maximum height */
         Gint   expansions;   /* number of character expansions factors */
         Gdc    min_ex;       /* minimum expansion factor */
         Gdc    max_ex;       /* maximum expansion factor */
         Gint   predefined;   /* number of predefined bundles */
   } Gtxfac;
/* Gdefloc - default locator data */
   typedef struct {
         Gwpoint  position;   /* initial position */
         Gint     n_pets;     /* number of prompt and echo types */
         Gpet    *pets;       /* list of prompt and echo types */
         Gdlimit  e_area;     /* default echo area */
         Glocrec  record;     /* default locator data record */
   } Gdefloc;
/* Gdefstroke - default stroke data */
   typedef struct {
         Gint        bufsiz;  /* initial buffer size */
         Gint        n_pets;  /* number of prompt and echo types */
         Gpet       *pets;    /* list of prompt and echo types */
         Gdlimit     e_area;  /* default echo area */
         Gstrokerec  record;  /* default stroke data record */
   } Gdefstroke;
/* Gqstroke - request stroke */
   typedef struct {
         Gistat  status;   /* request status */
         Gstroke stroke;   /* stroke data */
   } Gqstroke;
/* Gtxattr - text attributes */
   typedef struct {
         Gasf     tx_fp;      /* text font and precision ASF */
         Gasf     tx_exp;     /* text expansion ASF */
         Gasf     tx_space;   /* text character spacing ASF */
         Gasf     tx_colour;  /* text colour ASF */
         Gindex   text;       /* text index */
         Gtxbundl txbundl;    /* text bundle */
   } Gtxattr;
/* Gwsti - workstation transformation information */
   typedef struct {
         Gwstus  wstus;    /* workstation transformation update state */
         Gwstran request;  /* requested transformation */
         Gwstran current;  /* current transformation */
   } Gwsti;

#endif