path: root/ast/grf_pgplot.c

/*
*  Name:
*     grf_pgplot.c

*  Purpose:
*     Implement the grf module using the PGPLOT graphics system.

*  Description:
*     This file implements the low level graphics functions required
*     by the rest of AST, by calling suitable PGPLOT functions (the
*     FORTRAN PGPLOT interface is used).
*
*     This file can be used as a template for the development of
*     similar modules to support alternative graphics systems.

*  Copyright:
*     Copyright (C) 1997-2006 Council for the Central Laboratory of the
*     Research Councils

*  Licence:
*     This program is free software: you can redistribute it and/or
*     modify it under the terms of the GNU Lesser General Public
*     License as published by the Free Software Foundation, either
*     version 3 of the License, or (at your option) any later
*     version.
*     
*     This program is distributed in the hope that it will be useful,
*     but WITHOUT ANY WARRANTY; without even the implied warranty of
*     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*     GNU Lesser General Public License for more details.
*     
*     You should have received a copy of the GNU Lesser General
*     License along with this program.  If not, see
*     <http://www.gnu.org/licenses/>.

*  Authors:
*     DSB: David S. Berry (Starlink)
*     RFWS: R.F. Warren-Smith (Starlink)

*  History:
*     27-JUN-1996 (DSB):
*        Original version.
*     13-NOV-1996 (DSB):
*        Use C wrappers for PGPLOT functions.
*     15-NOV-1996 (RFWS):
*        Merged the C interface to PGPLOT into this file so that the
*        interface functions can be static.
*     7-OCT-1997 (DSB):
*        Corrected astGText and astGTxExt, by including a check for
*        reversed axes. Previously, the up-vector was used as supplied
*        even if the axes had been reversed.
*     15-OCT-1997 (DSB):
*        o  Corrected astGText and astGTxExt to take account of non-equal
*        scales on the two axes.
*        o  Modified astGTxExt so that it includes any leading or trailing
*        spaces in the returned box.
*        o  Added astGAxScale.
*     28-OCT-1998 (DSB):
*        o  Changed interpretation of the Width attribute from inches, to
*        a multiple of a small line width.
*        o  Wrapper for pgplot F77 subroutine PGQVSZ added.
*     30-JAN-2004 (DSB):
*        o  Added GCap
*        o  Renamed GAxScale as GScales
*     4-MAR-2011 (DSB):
*        Added astGBBuf and astGEBuf.
*/

/* Macros */
/* ====== */
#define MXSTRLEN 80              /* String length at which truncation starts
                                    within pgqtxt and pgptxt. */

/* Header files. */
/* ============= */
/* Interface definitions. */
/* ---------------------- */
#include "f77.h"                 /* FORTRAN <-> C interface macros (SUN/209) */
#include "c2f77.h"               /* C to FORTRAN interface functions */
#include "pointset.h"            /* Defines AST__BAD */
#include "memory.h"              /* Memory allocation facilities */
#include "error.h"               /* Error reporting facilities */
#include "grf.h"                 /* Interface to this module */

/* Error code definitions. */
/* ----------------------- */
#include "ast_err.h"             /* AST error codes */

/* C header files. */
/* --------------- */
#include <float.h>
#include <math.h>
#include <string.h>

/* Constants. */
/* ========== */
#define R2D 57.29578             /* Radians to degrees factor */

/* Function Prototypes. */
/* ==================== */
/* These define a local C interface to the PGPLOT library. */
static void ccpgline(int n, float xpts[], float ypts[] );
static void ccpgpt(int n, float xpts[], float ypts[], int symbol);
static void ccpgptxt(float x, float y, float angle, float fjust, char *text );
static void ccpgqcf(int *cf);
static void ccpgqch(float *ch);
static void ccpgqci(int *ci);
static void ccpglen(int units, char *text, float *xl, float *yl);
static void ccpgqcs(int units, float *xch, float *ych);
static void ccpgqls(int *ls);
static void ccpgqlw(int *lw);
static void ccpgqtbg(int *tbci);
static void ccpgqtxt(float x, float y, float angle, float fjust, char *text, float xbox[], float ybox[]);
static void ccpgqvp(int units, float *x1, float *x2, float *y1, float *y2);
static void ccpgqvsz(int units, float *x1, float *x2, float *y1, float *y2);
static void ccpgqwin(float *x1, float *x2, float *y1, float *y2);
static void ccpgscf(int cf);
static void ccpgsch(float ch);
static void ccpgsci(int ci);
static void ccpgsls(int ls);
static void ccpgslw(int lw);
static void ccpgstbg(int tbci);
static void ccpgupdt( void );
static void ccpgbbuf( void );
static void ccpgebuf( void );

/* These describe the native Fortran interface to the PGPLOT library. The
   macros used come from the "f77.h" include file. */
F77_SUBROUTINE(pgline)( INTEGER(n), REAL_ARRAY(x), REAL_ARRAY(y) );
F77_SUBROUTINE(pgpt)( INTEGER(n), REAL_ARRAY(x), REAL_ARRAY(y), INTEGER(TYPE) );
F77_SUBROUTINE(pgptxt)( REAL(x), REAL(y), REAL(angle), REAL(fjust), CHARACTER(text) TRAIL(text) );
F77_SUBROUTINE(pgqcf)( INTEGER(ival) );
F77_SUBROUTINE(pgqch)( REAL(rval) );
F77_SUBROUTINE(pgqci)( INTEGER(ival) );
F77_SUBROUTINE(pgqcs)( INTEGER(units), REAL(chv), REAL(chh) );
F77_SUBROUTINE(pglen)( INTEGER(units), CHARACTER(text), REAL(xl), REAL(yl) TRAIL(text) );
F77_SUBROUTINE(pgqls)( INTEGER(ival) );
F77_SUBROUTINE(pgqlw)( INTEGER(ival) );
F77_SUBROUTINE(pgqtbg)( INTEGER(tbg) );
F77_SUBROUTINE(pgqtxt)( REAL(x), REAL(y), REAL(angle), REAL(fjust), CHARACTER(text), REAL_ARRAY(xbox), REAL_ARRAY(ybox) TRAIL(text) );
F77_SUBROUTINE(pgqvp)( INTEGER(units), REAL(vx1), REAL(vx2), REAL(vy1), REAL(vy2) );
F77_SUBROUTINE(pgqvsz)( INTEGER(units), REAL(x1), REAL(x2), REAL(y1), REAL(y2) );
F77_SUBROUTINE(pgqwin)( REAL(wx1), REAL(wx2), REAL(wy1), REAL(wy2) );
F77_SUBROUTINE(pgscf)( INTEGER(ival) );
F77_SUBROUTINE(pgsch)( REAL(rval) );
F77_SUBROUTINE(pgsci)( INTEGER(ival) );
F77_SUBROUTINE(pgsls)( INTEGER(ival) );
F77_SUBROUTINE(pgslw)( INTEGER(ival) );
F77_SUBROUTINE(pgstbg)( INTEGER(tbg) );
F77_SUBROUTINE(pgupdt)( );
F77_SUBROUTINE(pgbbuf)( );
F77_SUBROUTINE(pgebuf)( );

/* Externally visible functions. */
/* ============================= */
/* These implement the "grf" interface in terms of the local C interface
   to PGPLOT. */
int astGBBuf( void ){
/*
*+
*  Name:
*     astGBBuf

*  Purpose:
*     Start a new graphics buffering context.

*  Synopsis:
*     #include "grf.h"
*     int astGBBuf( void )

*  Description:
*     This function begins saving graphical output commands in an
*     internal buffer; the commands are held until a matching astGEBuf
*     call (or until the buffer is emptied by astGFlush). This can
*     greatly improve the efficiency of some graphics systems. astGBBuf
*     increments an internal counter, while astGEBuf decrements this
*     counter and flushes the buffer to the output device when the
*     counter drops to zero.  astGBBuf and astGEBuf calls should always
*     be paired.

*  Parameters:
*     None.

*  Returned Value:
*     A value of 0 is returned if an error occurs, and 1 is returned
*     otherwise.

*-
*/
   ccpgbbuf();
   return 1;
}

int astGEBuf( void ){
/*
*+
*  Name:
*     astGEBuf

*  Purpose:
*     End a graphics buffering context.

*  Synopsis:
*     #include "grf.h"
*     int astGEBuf( void )

*  Description:
*     This function marks the end of a batch of graphical output begun
*     with the last call of astGBBuf.  astGBBuf and astGEBUF calls should
*     always be paired. Each call to astGBBuf increments a counter, while
*     each call to astGEBuf decrements the counter. When the counter
*     reaches 0, the batch of output is written on the output device.

*  Parameters:
*     None.

*  Returned Value:
*     A value of 0 is returned if an error occurs, and 1 is returned
*     otherwise.

*-
*/
   ccpgebuf();
   return 1;
}

int astGFlush( void ){
/*
*+
*  Name:
*     astGFlush

*  Purpose:
*     Flush all pending graphics to the output device.

*  Synopsis:
*     #include "grf.h"
*     int astGFlush( void )

*  Description:
*     This function ensures that the display device is up-to-date,
*     by flushing any pending graphics to the output device.

*  Parameters:
*     None.

*  Returned Value:
*     A value of 0 is returned if an error occurs, and 1 is returned
*     otherwise.

*-
*/

   ccpgupdt();
   return 1;
}

int astGCap( int cap, int value ){
/*
*+
*  Name:
*     astGCap

*  Purpose:
*     Indicate if this grf module has a given capability.

*  Synopsis:
*     #include "grf.h"
*     int astGCap( int cap, int value )

*  Description:
*     This function is called by the AST Plot class to determine if the
*     grf module has a given capability, as indicated by the "cap"
*     argument.

*  Parameters:
*     cap
*        The capability being inquired about. This will be one of the
*        following constants defined in grf.h:
*
*        GRF__SCALES: This function should return a non-zero value if
*        it implements the astGScales function, and zero otherwise. The
*        supplied "value" argument should be ignored.
*
*        GRF__MJUST: This function should return a non-zero value if
*        the astGText and astGTxExt functions recognise "M" as a
*        character in the justification string. If the first character of
*        a justification string is "M", then the text should be justified
*        with the given reference point at the bottom of the bounding box.
*        This is different to "B" justification, which requests that the
*        reference point be put on the baseline of the text, since some
*        characters hang down below the baseline. If the astGText or
*        astGTxExt function cannot differentiate between "M" and "B",
*        then this function should return zero, in which case "M"
*        justification will never be requested by Plot. The supplied
*        "value" argument should be ignored.
*
*        GRF__ESC: This function should return a non-zero value if the
*        astGText and astGTxExt functions can recognise and interpret
*        graphics escape sequences within the supplied string. These
*        escape sequences are described below. Zero should be returned
*        if escape sequences cannot be interpreted (in which case the
*        Plot class will interpret them itself if needed). The supplied
*        "value" argument should be ignored only if escape sequences cannot
*        be interpreted by astGText and astGTxExt. Otherwise, "value"
*        indicates whether astGText and astGTxExt should interpret escape
*        sequences in subsequent calls. If "value" is non-zero then
*        escape sequences should be interpreted by astGText and
*        astGTxExt. Otherwise, they should be drawn as literal text.

*  Returned Value:
*     The return value, as described above. Zero should be returned if
*     the supplied capability is not recognised.

*  Escape Sequences:
*     Escape sequences are introduced into the text string by a percent
*     "%" character. The following escape sequences are currently recognised
*     ("..." represents a string of one or more decimal digits):
*
*       %%      - Print a literal "%" character (type GRF__ESPER ).
*
*       %^...+  - Draw subsequent characters as super-scripts. The digits
*                 "..." give the distance from the base-line of "normal"
*                 text to the base-line of the super-script text, scaled
*                 so that a value of "100" corresponds to the height of
*                 "normal" text (type GRF__ESSUP ).
*       %^+     - Draw subsequent characters with the normal base-line.
*
*       %v...+  - Draw subsequent characters as sub-scripts. The digits
*                 "..." give the distance from the base-line of "normal"
*                 text to the base-line of the sub-script text, scaled
*                 so that a value of "100" corresponds to the height of
*                 "normal" text (type GRF__ESSUB ).
*
*       %v+     - Draw subsequent characters with the normal base-line
*                 (equivalent to %^+).
*
*       %>...+  - Leave a gap before drawing subsequent characters.
*                 The digits "..." give the size of the gap, scaled
*                 so that a value of "100" corresponds to the height of
*                 "normal" text (type GRF__ESGAP ).
*
*       %<...+  - Move backwards before drawing subsequent characters.
*                 The digits "..." give the size of the movement, scaled
*                 so that a value of "100" corresponds to the height of
*                 "normal" text (type GRF_ESBAC).
*
*       %s...+  - Change the Size attribute for subsequent characters. The
*                 digits "..." give the new Size as a fraction of the
*                 "normal" Size, scaled so that a value of "100" corresponds
*                 to 1.0  (type GRF__ESSIZ ).
*
*       %s+     - Reset the Size attribute to its "normal" value.
*
*       %w...+  - Change the Width attribute for subsequent characters. The
*                 digits "..." give the new width as a fraction of the
*                 "normal" Width, scaled so that a value of "100" corresponds
*                 to 1.0  (type GRF__ESWID ).
*
*       %w+     - Reset the Size attribute to its "normal" value.
*
*       %f...+  - Change the Font attribute for subsequent characters. The
*                 digits "..." give the new Font value  (type GRF__ESFON ).
*
*       %f+     - Reset the Font attribute to its "normal" value.
*
*       %c...+  - Change the Colour attribute for subsequent characters. The
*                 digits "..." give the new Colour value  (type GRF__ESCOL ).
*
*       %c+     - Reset the Colour attribute to its "normal" value.
*
*       %t...+  - Change the Style attribute for subsequent characters. The
*                 digits "..." give the new Style value  (type GRF__ESSTY ).
*
*       %t+     - Reset the Style attribute to its "normal" value.
*
*       %-      - Push the current graphics attribute values onto the top of
*                 the stack - see "%+" (type GRF__ESPSH).
*
*       %+      - Pop attributes values of the top the stack - see "%-". If
*                 the stack is empty, "normal" attribute values are restored
*                 (type GRF__ESPOP).
*
*     The astFindEscape function (in libast.a) can be used to locate escape
*     sequences within a text string. It has the following signature:
*
*     #include "plot.h"
*     int astFindEscape( const char *text, int *type, int *value, int *nc )
*
*     Parameters:
*        text
*           Pointer to the string to be checked.
*        type
*           Pointer to a location at which to return the type of escape
*           sequence. Each type is identified by a symbolic constant defined
*           in grf.h and is indicated in the above section. The returned value
*           is undefined if the supplied text does not begin with an escape
*           sequence.
*        value
*           Pointer to a lcation at which to return the integer value
*           associated with the escape sequence. All usable values will be
*           positive. Zero is returned if the escape sequence has no associated
*           integer. A value of -1 indicates that the attribute identified by
*           "type" should be reset to its "normal" value (as established using
*           the astGAttr function, etc). The returned value is undefined if
*           the supplied text does not begin with an escape sequence.
*        nc
*           Pointer to a location at which to return the number of
*           characters read by this call. If the text starts with an escape
*           sequence, the returned value will be the number of characters in
*           the escape sequence. Otherwise, the returned value will be the
*           number of characters prior to the first escape sequence, or the
*           length of the supplied text if no escape sequence is found.

*     Returned Value:
*        A non-zero value is returned if the supplied text starts with a
*        graphics escape sequence, and zero is returned otherwise.

*-
*/

   int result = 0;
   if( cap == GRF__SCALES ) result = 1;
   return result;
}

int astGLine( int n, const float *x, const float *y ){
/*
*+
*  Name:
*     astGLine

*  Purpose:
*     Draw a polyline (i.e. a set of connected lines).

*  Synopsis:
*     #include "grf.h"
*     int astGLine( int n, const float *x, const float *y )

*  Description:
*     This function displays lines joining the given positions.

*  Parameters:
*     n
*        The number of positions to be joined together.
*     x
*        A pointer to an array holding the "n" x values.
*     y
*        A pointer to an array holding the "n" y values.

*  Returned Value:
*     A value of 0 is returned if an error occurs, and 1 is returned
*     otherwise.

*  Notes:
*     -  Nothing is done if "n" is less than 2, or if a NULL pointer is
*     given for either "x" or "y".

*-
*/

   if( n > 1 && x && y ) ccpgline( n, (float *) x, (float *) y );
   return 1;
}

int astGMark( int n, const float *x, const float *y, int type ){
/*
*+
*  Name:
*     astGMark

*  Purpose:
*     Draw a set of markers.

*  Synopsis:
*     #include "grf.h"
*     int astGMark( int n, const float *x, const float *y, int type )

*  Description:
*     This function displays markers at the given positions.

*  Parameters:
*     n
*        The number of markers to draw.
*     x
*        A pointer to an array holding the "n" x values.
*     y
*        A pointer to an array holding the "n" y values.
*     type
*        An integer which can be used to indicate the type of marker symbol
*        required.

*  Returned Value:
*     A value of 0 is returned if an error occurs, and 1 is returned
*     otherwise.

*  Notes:
*     -  Nothing is done if "n" is less than 1, or if a NULL pointer is
*     given for either "x" or "y".

*-
*/

   if( n > 0 && x && y ) ccpgpt( n, (float *) x, (float *) y, type );
   return 1;
}

int astGText( const char *text, float x, float y, const char *just,
              float upx, float upy ){
/*
*+
*  Name:
*     astGText

*  Purpose:
*     Draw a character string.

*  Synopsis:
*     #include "grf.h"
*     int astGText( const char *text, float x, float y, const char *just,
*                   float upx, float upy )

*  Description:
*     This function displays a character string at a given position
*     using a specified justification and up-vector.

*  Parameters:
*     text
*        Pointer to a null-terminated character string to be displayed.
*     x
*        The reference x coordinate.
*     y
*        The reference y coordinate.
*     just
*        A character string which specifies the location within the
*        text string which is to be placed at the reference position
*        given by x and y. The first character may be 'T' for "top",
*        'C' for "centre", or 'B' for "bottom", and specifies the
*        vertical location of the reference position. Note, "bottom"
*        corresponds to the base-line of normal text. Some characters
*        (eg "y", "g", "p", etc) descend below the base-line. The second
*        character may be 'L' for "left", 'C' for "centre", or 'R'
*        for "right", and specifies the horizontal location of the
*        reference position. If the string has less than 2 characters
*        then 'C' is used for the missing characters.
*     upx
*        The x component of the up-vector for the text, in graphics world
*        coordinates. If necessary the supplied value should be negated
*        to ensure that positive values always refer to displacements from
*        left to right on the screen.
*     upy
*        The y component of the up-vector for the text, in graphics world
*        coordinates. If necessary the supplied value should be negated
*        to ensure that positive values always refer to displacements from
*        bottom to top on the screen.

*  Returned Value:
*     A value of 0 is returned if an error occurs, and 1 is returned
*     otherwise.

*  Notes:
*     -  Any graphics within the rotated box enclosing the text are erased.
*     -  A NULL value for "just" causes a value of "CC" to be used.
*     -  Both "upx" and "upy" being zero causes an error.
*     -  Any unrecognised character in "just" causes an error.
*-
*/

/* Local Variables: */
   char lj[ 2 ];
   float uplen, xbox[ 4 ], ybox[ 4 ];
   float angle, fjust, hu, test, alpha, beta;
   int i, tbg;

/* Check that there is something to draw. */
   if( text && text[ 0 ] != 0 ){

/* Fill in any missing parts of the justification string. */
      if( just ){
         if( just[ 0 ] == 'T' || just[ 0 ] == 'C' || just[ 0 ] == 'B' ){
            lj[ 0 ] = just[ 0 ];
         } else {
            astError( AST__GRFER, "astGText: Justification string '%s' is "
                      "invalid.", just );
            return 0;
         }

         if( just[ 1 ] == 'L' || just[ 1 ] == 'C' || just[ 1 ] == 'R' ){
            lj[ 1 ] = just[ 1 ];
         } else {
            astError( AST__GRFER, "astGText: Justification string '%s' "
                      "is invalid.", just );
            return 0;
         }

      } else {
         lj[ 0 ] = 'C';
         lj[ 1 ] = 'C';
      }

/* Find the conversion factors between increment in world coordinate axes,
   and the corresponding increments in millimetres ( Xmm = alpha*Xworld,
   Ymm = beta*Yworld ). */
      if( !astGScales( &alpha, &beta ) ) return 0;

/* If either axis is reversed, reverse the supplied up-vector components
   so that they refer to the world-coordinates axes. */
      if( alpha < 0.0 ) upx = -upx;
      if( beta < 0.0 ) upy = -upy;

/* Get the angle between the text base-line and horizontal. */
      angle = atan2( -(double) upx*alpha, (double) upy*beta )*R2D;

/* Get the fractional horizontal justification as needed by PGPLOT. */
      if( lj[ 1 ] == 'L' ) {
         fjust = 0.0;
      } else if( lj[ 1 ] == 'R' ) {
         fjust = 1.0;
      } else {
         fjust = 0.5;
      }

/* Unless the requested justification is "Bottom", we need to adjust
   the supplied reference position before we use it with PGPLOT because
   PGPLOT assumes "Bottom" justification. */
      if( lj[0] != 'B' ) {

/* Get the bounding box of the string. Note, only the size of the box is
   significant here, not its position. Also note, leading and trailing
   spaces are not included in the bounding box. */
         ccpgqtxt( x, y, angle, fjust, (char *) text, xbox, ybox );

/* Normalise the up-vector in world coordinates. */
         uplen = sqrt( (double) (upx*upx + upy*upy) );
         if( uplen > 0.0 ){
            upx /= uplen;
            upy /= uplen;
         } else {
            astError( AST__GRFER, "astGText: Zero length up-vector supplied.");
            return 0;
         }

/* Find the height of the text above the base-line. Note, the PGPLOT
   manual is not clear about the order of the corners returned by
   pgqtxt, so we have to find the largest distance between
   the corners in the direction of the supplied up-vector. */
         hu = 0.0;
         for( i = 0; i < 4; i++ ){
            test = upx*( xbox[ i ] - x ) + upy*( ybox[ i ] - y );
            if( test > hu ) hu = test;
         }

/* Adjust the vertical position of the reference point, since PGPLOT
   requires it to be at the bottom of the text. */
         if( lj[ 0 ] == 'T' ){
            x -= upx*hu;
            y -= upy*hu;
         } else if( lj[ 0 ] == 'C' ){
            x -= 0.5*upx*hu;
            y -= 0.5*upy*hu;
         }
      }

/* Display the text, erasing any graphics. */
      ccpgqtbg( &tbg );
      ccpgstbg( 0 );
      ccpgptxt( x, y, angle, fjust, (char *) text );
      ccpgstbg( tbg );
   }

/* Return. */
   return 1;
}

int astGScales( float *alpha, float *beta ){
/*
*+
*  Name:
*     astGScales

*  Purpose:
*     Get the axis scales.

*  Synopsis:
*     #include "grf.h"
*     int astGScales( float *alpha, float *beta )

*  Description:
*     This function returns two values (one for each axis) which scale
*     increments on the corresponding axis into a "normal" coordinate
*     system in which:
*        1 - The axes have equal scale in terms of (for instance)
*            millimetres per unit distance.
*        2 - X values increase from left to right.
*        3 - Y values increase from bottom to top.

*  Parameters:
*     alpha
*        A pointer to the location at which to return the scale for the
*        X axis (i.e. Xnorm = alpha*Xworld).
*     beta
*        A pointer to the location at which to return the scale for the
*        Y axis (i.e. Ynorm = beta*Yworld).

*  Returned Value:
*     A value of 0 is returned if an error occurs, and 1 is returned
*     otherwise.

*-
*/

/* Local Variables: */
   float nx1, nx2, ny1, ny2, wx1, wx2, wy1, wy2;
   int ret;

/* Find the conversion factors between increment in world coordinate axes,
   and the corresponding increments in millimetres ( Xmm = alpha*Xworld,
   Ymm = beta*Yworld ). */
   ccpgqvp( 2, &nx1, &nx2, &ny1, &ny2 );
   ccpgqwin( &wx1, &wx2, &wy1, &wy2 );

   if( wx2 != wx1 && wy2 != wy1 &&
       nx2 != nx1 && ny2 != ny1 ) {
      *alpha= ( nx2 - nx1 ) / ( wx2 - wx1 );
      *beta = ( ny2 - ny1 ) / ( wy2 - wy1 );
      ret = 1;
   } else {
      astError( AST__GRFER, "astGScales: The graphics window or viewport has zero size." );
      ret = 0;
   }

   return ret;
}

int astGTxExt( const char *text, float x, float y, const char *just,
               float upx, float upy, float *xb, float *yb ){
/*
*+
*  Name:
*     astGTxExt

*  Purpose:
*     Get the extent of a character string.

*  Synopsis:
*     #include "grf.h"
*     int astGTxExt( const char *text, float x, float y, const char *just,
*                   float upx, float upy, float *xb, float *yb )

*  Description:
*     This function returns the corners of a box which would enclose the
*     supplied character string if it were displayed using astGText.
*
*     The returned box INCLUDES any leading or trailing spaces.

*  Parameters:
*     text
*        Pointer to a null-terminated character string to be displayed.
*     x
*        The reference x coordinate.
*     y
*        The reference y coordinate.
*     just
*        A character string which specifies the location within the
*        text string which is to be placed at the reference position
*        given by x and y. The first character may be 'T' for "top",
*        'C' for "centre", or 'B' for "bottom", and specifies the
*        vertical location of the reference position. Note, "bottom"
*        corresponds to the base-line of normal text. Some characters
*        (eg "y", "g", "p", etc) descend below the base-line. The second
*        character may be 'L' for "left", 'C' for "centre", or 'R'
*        for "right", and specifies the horizontal location of the
*        reference position. If the string has less than 2 characters
*        then 'C' is used for the missing characters.
*     upx
*        The x component of the up-vector for the text, in graphics world
*        coordinates. If necessary the supplied value should be negated
*        to ensure that positive values always refer to displacements from
*        left to right on the screen.
*     upy
*        The y component of the up-vector for the text, in graphics world
*        coordinates. If necessary the supplied value should be negated
*        to ensure that positive values always refer to displacements from
*        bottom to top on the screen.
*     xb
*        An array of 4 elements in which to return the x coordinate of
*        each corner of the bounding box.
*     yb
*        An array of 4 elements in which to return the y coordinate of
*        each corner of the bounding box.

*  Returned Value:
*     A value of 0 is returned if an error occurs, and 1 is returned
*     otherwise.

*  Notes:
*     -  The order of the corners is anti-clockwise (in world coordinates)
*        starting at the bottom left.
*     -  A NULL value for "just" causes a value of "CC" to be used.
*     -  Both "upx" and "upy" being zero causes an error.
*     -  Any unrecognised character in "just" causes an error.
*     -  Zero is returned for all bounds of the box if an error occurs.

*-
*/

/* Local Variables: */
   char lj[ 2 ];
   float udx, udy, vdx, vdy, vx, vy, uplen, xbox[ 4 ],
         ybox[ 4 ], uxu, uyu, uxd, uyd, ux, uy;
   float angle, width, test, xl, yl;
   float alpha, beta, xc, yc, hu, hd, a, b;
   int i;

/* Initialise the returned values to indicate no box available. */
   for( i = 0; i < 4; i++ ){
      xb[ i ] = 0.0;
      yb[ i ] = 0.0;
   }

/* Check that there is something to draw. */
   if( text && text[ 0 ] != 0 ){

/* Fill in any missing parts of the justification string. */
      if( just ){
         if( just[ 0 ] == 'T' || just[ 0 ] == 'C' || just[ 0 ] == 'B' ){
            lj[ 0 ] = just[ 0 ];
         } else {
            astError( AST__GRFER, "astGTxExt: Justification string '%s' is "
                      "invalid.", just );
            return 0;
         }

         if( just[ 1 ] == 'L' || just[ 1 ] == 'C' || just[ 1 ] == 'R' ){
            lj[ 1 ] = just[ 1 ];
         } else {
            astError( AST__GRFER, "astGTxExt: Justification string '%s' is "
                      "invalid.", just );
            return 0;
         }

      } else {
         lj[ 0 ] = 'C';
         lj[ 1 ] = 'C';
      }

/* Find the conversion factors between increment in world coordinate axes,
   and the corresponding increments in millimetres ( Xmm = alpha*Xworld,
   Ymm = beta*Yworld ). */
      if( !astGScales( &alpha, &beta ) ) return 0;

/* If either axis is reversed, reverse the supplied up-vector components
   so that they refer to the world-coordinates axes. */
      if( alpha < 0.0 ) upx = -upx;
      if( beta < 0.0 ) upy = -upy;

/* Convert the up-vector into millimetres. */
      ux = alpha*upx;
      uy = beta*upy;

/* Normalise the up-vector to a length of 1 millimetre. */
      uplen = sqrt( (double) (ux*ux + uy*uy) );
      if( uplen > 0.0 ){
         ux /= uplen;
         uy /= uplen;
      } else {
         astError( AST__GRFER, "astGText: Zero length up-vector supplied.");
         return 0;
      }

/* Form the base-line vector by rotating the up-vector by 90 degrees
   clockwise. */
      vx = uy;
      vy = -ux;

/* Get the angle between the text base-line and horizontal. */
      angle = atan2( (double) vy, (double) vx )*R2D;

/* Get the bounding box of the string drawn with its bottom left corner
   at the origin. */
      ccpgqtxt( 0.0, 0.0, angle, 0.0, (char *) text, xbox, ybox );

/* Convert the returned bounding box world coordinates into millimetres. */
      for( i = 0; i < 4; i++ ){
         xbox[ i ] *= alpha;
         ybox[ i ] *= beta;
      }

/* Find the height of the bounding box, in millimetres. Note,
   the PGPLOT manual is not clear about the order of the corners
   returned by pgqtxt, so we have to find the largest distance between
   the corners in the direction of the supplied up-vector. The reference
   point is on the text base-line which is not usually at the bottom of
   the bounding box (some letters - like "y" - extend below the base-line).
   Find the distance from the base-line to the top (hu) and bottom (hd)
   of the bounding box. */
      hu = -FLT_MAX;
      hd = FLT_MAX;
      for( i = 0; i < 4; i++ ){
         test = ux*xbox[ i ] + uy*ybox[ i ];
         if( test > hu ) hu = test;
         if( test < hd ) hd = test;
      }

/* Get an up and a down vector scaled to the height/depth of the
   bounding box above/below the text base-line . */
      uxu = ux*hu;
      uyu = uy*hu;
      uxd = ux*hd;
      uyd = uy*hd;

/* The bounding box returned by pgqtxt does not include any leading or
   trailing spaces. We need to include such spaces in the returned box.
   To do this we get the length of the text string in millimetres
   using pglen instead of using the bounding box returned by pgqtxt. */
      ccpglen( 2, (char *) text, &xl, &yl );

/* The abolute width of the string in millimetres may depend on the
   up-vector. The values returned by pglen are for horizontal and
   vertical text. Find the width using the supplied up-vector. */
      a = uy*xl;
      b = ux*yl;
      width = sqrt( a*a + b*b );

/* The pglen function returns a value which is slightly smaller than
   the area cleared to hold the text when written using pgptxt. Increase
   the text width so that it is about equal to the area cleared. */
      width += 0.2*hu;

/* Scale the base-line vector so that its length is equal to the width
   of the bounding box (including spaces). */
      vx *= width;
      vy *= width;

/* Convert the base-line vector back into world coordinates. */
      vx /= alpha;
      vy /= beta;

/* Convert the up and down vectors into world coordinates. */
      uxu /= alpha;
      uyu /= beta;
      uxd /= alpha;
      uyd /= beta;

/* Find the coordinates at the centre of the bounding box in world
   coordinates. */
      xc = x;
      yc = y;

      if( lj[0] == 'B' ) {
         xc += 0.5*uxu;
         yc += 0.5*uyu;
      } else if( lj[0] == 'T' ) {
         xc -= 0.5*uxu;
         yc -= 0.5*uyu;
      }

      if( lj[1] == 'L' ) {
         xc += 0.5*vx;
         yc += 0.5*vy;
      } else if( lj[1] == 'R' ) {
         xc -= 0.5*vx;
         yc -= 0.5*vy;
      }

/* Get the corners of the bounding box. */
      vdx = 0.5*vx;
      vdy = 0.5*vy;
      udx = 0.5*uxu;
      udy = 0.5*uyu;

/* Bottom left corner... */
      xb[ 0 ] = xc - vdx - udx + uxd;
      yb[ 0 ] = yc - vdy - udy + uyd;

/* Bottom right corner... */
      xb[ 1 ] = xc + vdx - udx + uxd;
      yb[ 1 ] = yc + vdy - udy + uyd;

/* Top right corner... */
      xb[ 2 ] = xc + vdx + udx;
      yb[ 2 ] = yc + vdy + udy;

/* Top left corner... */
      xb[ 3 ] = xc - vdx + udx;
      yb[ 3 ] = yc - vdy + udy;

   }

/* Return. */
   return 1;
}

int astGQch( float *chv, float *chh ){
/*
*+
*  Name:
*     astGQch

*  Purpose:
*     Return the character height in world coordinates.

*  Synopsis:
*     #include "grf.h"
*     int astGQch( float *chv, float *chh )

*  Description:
*     This function returns the heights of characters drawn vertically and
*     horizontally in world coordinates.

*  Parameters:
*     chv
*        A pointer to the double which is to receive the height of
*        characters drawn with a vertical baseline . This will be an
*        increment in the X axis.
*     chh
*        A pointer to the double which is to receive the height of
*        characters drawn with a horizontal baseline. This will be an
*        increment in the Y axis.

*  Returned Value:
*     A value of 0 is returned if an error occurs, and 1 is returned
*     otherwise.

*-
*/

/* Local Variables: */
   float vx1,vx2,vy1,vy2,wx1,wx2,wy1,wy2;

/* Get the character height in normalised device coordinates */
   ccpgqcs( 0, chv, chh );

/* Get the bounds of the PGPLOT viewport in normalised device
   coordinates. */
   ccpgqvp( 0, &vx1, &vx2, &vy1, &vy2 );

/* Get the bounds of the PGPLOT window in world coordinates. */
   ccpgqwin( &wx1, &wx2, &wy1, &wy2 );

/* Convert the text height from normalised device coordinates into world
   coordinates for vertical text. Print an error message if the viewport
   has zero size. */
   if( vx1 != vx2 ){
      *chv *= ( wx2 - wx1 )/( vx2 - vx1 );

   } else {
      astError( AST__GRFER, "astGQch: The graphics viewport has zero size "
                "in the X direction.");
      return 0;
   }

/* Convert the text height from normalised device coordinates into world
   coordinates for horizontal text. Print an error message if the viewport
   has zero size. */
   if( vy1 != vy2 ){
      *chh *= ( wy2 - wy1 )/( vy2 - vy1 );
   } else {
      astError( AST__GRFER, "astGQch: The graphics viewport has zero size "
                "in the Y direction.");
      return 0;
   }

/* Return. */
   return 1;
}

int astGAttr( int attr, double value, double *old_value, int prim ){
/*
*+
*  Name:
*     astGAttr

*  Purpose:
*     Enquire or set a graphics attribute value.

*  Synopsis:
*     #include "grf.h"
*     int int astGAttr( int attr, double value, double *old_value, int prim )

*  Description:
*     This function returns the current value of a specified graphics
*     attribute, and optionally establishes a new value. The supplied
*     value is converted to an integer value if necessary before use.

*  Parameters:
*     attr
*        An integer value identifying the required attribute. The
*        following symbolic values are defined in grf.h:
*
*           GRF__STYLE  - Line style.
*           GRF__WIDTH  - Line width.
*           GRF__SIZE   - Character and marker size scale factor.
*           GRF__FONT   - Character font.
*           GRF__COLOUR - Colour index.
*     value
*        A new value to store for the attribute. If this is AST__BAD
*        no value is stored.
*     old_value
*        A pointer to a double in which to return the attribute value.
*        If this is NULL, no value is returned.
*     prim
*        The sort of graphics primitive to be drawn with the new attribute.
*        Identified by the following values defined in grf.h:
*           GRF__LINE
*           GRF__MARK
*           GRF__TEXT

*  Returned Value:
*     A value of 0 is returned if an error occurs, and 1 is returned
*     otherwise.

*  Notes:

*-
*/

   int ival;
   float rval, dx, dy, deflw, x1, x2, y1, y2;

/* If required retrieve the current line style, and set a new line style. */
   if( attr == GRF__STYLE ){
      ccpgqls( &ival );
      if( old_value ) *old_value = (double) ival;

      if( value != AST__BAD ){
         ival = (int) ( value + 0.5 );
         if( value < 0.0 ) ival -= 1;

         ival = ( ival - 1 ) % 5;
         ival += ( ival < 0 ) ? 6 : 1;

         ccpgsls( ival );
      }

/* If required retrieve the current line width, and set a new line width.
   Line width is stored in Plot as a scale factor (1.0 for the default line
   width which is a fixed fraction of the diagonal of the view surface), but
   pgplot stores it in units of 0.005 of an inch. */
   } else if( attr == GRF__WIDTH ){

/* Get the bounds of the view surface in inches. */
      ccpgqvsz( 1, &x1, &x2, &y1, &y2 );

/* Find the default line width in inches (i.e. 0.0005 of the length
   of the view surface diagonal). */
      dx = ( x1 - x2 );
      dy = ( y1 - y2 );
      deflw = 0.0005*sqrt( (double )( dx*dx + dy*dy ) );

/* Get the current pgplot line width in units of 0.005 of an inch. */
      ccpgqlw( &ival );

/* If required, return the factor by which this exceeds the default line
   width found above. */
      if( old_value ) *old_value = (double)( ival )/( 200.0 * deflw );

/* If a new line width has been provided, the pgplot line width needs to
   be set to the corresponding absolute value. */
      if( value != AST__BAD ){
         ival = (int) ( 200.0*value*deflw );
         if( ival < 1 ) {
            ival = 1;
         } else if( ival > 201 ){
            ival = 201;
         }
         ccpgslw( ival );
      }

/* If required retrieve the current character size, and set a new size.
   The attribute value should be a factor by which to multiply the
   default character size. */
   } else if( attr == GRF__SIZE ){
      ccpgqch( &rval );
      if( old_value ) *old_value = (double) rval;

      if( value != AST__BAD ){
         ccpgsch( (float) value );
      }

/* If required retrieve the current character font, and set a new font. */
   } else if( attr == GRF__FONT ){
      ccpgqcf( &ival );
      if( old_value ) *old_value = (double) ival;

      if( value != AST__BAD ){
         ival = (int) ( value + 0.5 );
         if( value < 0.0 ) ival -= 1;

         ival = ( ival - 1 ) % 4;
         ival += ( ival < 0 ) ? 5 : 1;
         ccpgscf( ival );
      }

/* If required retrieve the current colour index, and set a new colour
   index. */
   } else if( attr == GRF__COLOUR ){
      ccpgqci( &ival );
      if( old_value ) *old_value = (double) ival;

      if( value != AST__BAD ){
         ival = (int) ( value + 0.5 );
         if( ival < 0 ) ival = 1;
         ccpgsci( ival );
      }

/* Give an error message for any other attribute value. */
   } else {
      astError( AST__GRFER, "astGAttr: Unknown graphics attribute '%d' "
                "requested.", attr );
      return 0;
   }

/* Return. */
   return 1;
}

/* Local Functions. */
/* ================ */
/* These implement the local C interface to PGPLOT in terms of its
   native Fortran interface. Only those PGPLOT functions used within
   this module are included. */
static void ccpgline(int n, float xpts[], float ypts[] ){
   F77_INTEGER_TYPE N;
   F77_REAL_TYPE *XX;
   F77_REAL_TYPE *YY;
   int i;

   XX = (F77_REAL_TYPE *) astMalloc( sizeof( F77_REAL_TYPE )*(size_t) n );
   YY = (F77_REAL_TYPE *) astMalloc( sizeof( F77_REAL_TYPE )*(size_t) n );

   if( astOK ){

      for( i = 0; i < n; i++ ){
         XX[ i ] = (F77_REAL_TYPE) xpts[ i ];
         YY[ i ] = (F77_REAL_TYPE) ypts[ i ];
      }

      N = (F77_INTEGER_TYPE) n;

      F77_CALL(pgline)( INTEGER_ARG(&N), REAL_ARRAY_ARG(XX),
                        REAL_ARRAY_ARG(YY) );

      XX = (F77_REAL_TYPE *) astFree( (void *) XX );
      YY = (F77_REAL_TYPE *) astFree( (void *) YY );
   }
}

static void ccpgpt(int n, float xpts[], float ypts[], int symbol){
   F77_INTEGER_TYPE N;
   F77_REAL_TYPE *XX;
   F77_REAL_TYPE *YY;
   F77_INTEGER_TYPE SYMBOL;
   int i;

   XX = (F77_REAL_TYPE *) astMalloc( sizeof( F77_REAL_TYPE )*(size_t) n );
   YY = (F77_REAL_TYPE *) astMalloc( sizeof( F77_REAL_TYPE )*(size_t) n );

   if( astOK ){

      for( i = 0; i < n; i++ ){
         XX[ i ] = (F77_REAL_TYPE) xpts[ i ];
         YY[ i ] = (F77_REAL_TYPE) ypts[ i ];
      }

      N = (F77_INTEGER_TYPE) n;
      SYMBOL = (F77_INTEGER_TYPE) symbol;


      F77_CALL(pgpt)( INTEGER_ARG(&N), REAL_ARRAY_ARG(XX),
                      REAL_ARRAY_ARG(YY), INTEGER_ARG(&SYMBOL) );

      XX = (F77_REAL_TYPE *) astFree( (void *) XX );
      YY = (F77_REAL_TYPE *) astFree( (void *) YY );
   }
}

static void ccpgptxt(float x, float y, float angle, float fjust, char *text ){
   F77_REAL_TYPE X;
   F77_REAL_TYPE Y;
   F77_REAL_TYPE ANGLE;
   F77_REAL_TYPE FJUST;
   DECLARE_CHARACTER(LTEXT,MXSTRLEN);
   int ftext_length;

   X = (F77_REAL_TYPE) x;
   Y = (F77_REAL_TYPE) y;
   ANGLE = (F77_REAL_TYPE) angle;
   FJUST = (F77_REAL_TYPE) fjust;

   ftext_length = strlen( text );
   if( ftext_length > LTEXT_length ) ftext_length = LTEXT_length;
   astStringExport( text, LTEXT, ftext_length );

   F77_CALL(pgptxt)( REAL_ARG(&X), REAL_ARG(&Y), REAL_ARG(&ANGLE),
                     REAL_ARG(&FJUST), CHARACTER_ARG(LTEXT)
                     TRAIL_ARG(ftext) );
}

static void ccpgqtxt(float x, float y, float angle, float fjust, char *text,
                     float xbox[], float ybox[]){
   F77_REAL_TYPE X;
   F77_REAL_TYPE Y;
   F77_REAL_TYPE ANGLE;
   F77_REAL_TYPE FJUST;
   DECLARE_CHARACTER(LTEXT,MXSTRLEN);
   F77_REAL_TYPE XBOX[ 4 ];
   F77_REAL_TYPE YBOX[ 4 ];
   int i;
   int ftext_length;

   X = (F77_REAL_TYPE) x;
   Y = (F77_REAL_TYPE) y;
   ANGLE = (F77_REAL_TYPE) angle;
   FJUST = (F77_REAL_TYPE) fjust;

   ftext_length = strlen( text );
   if( ftext_length > LTEXT_length ) ftext_length = LTEXT_length;
   astStringExport( text, LTEXT, ftext_length );

   F77_CALL(pgqtxt)( REAL_ARG(&X), REAL_ARG(&Y), REAL_ARG(&ANGLE),
                     REAL_ARG(&FJUST), CHARACTER_ARG(LTEXT),
                     REAL_ARRAY_ARG(XBOX), REAL_ARRAY_ARG(YBOX)
                     TRAIL_ARG(ftext) );

   for( i = 0; i < 4; i++ ){
      xbox[ i ] = (float) XBOX[ i ];
      ybox[ i ] = (float) YBOX[ i ];
   }

}

static void ccpgqtbg(int *tbci){
   F77_INTEGER_TYPE TBCI;
   F77_CALL(pgqtbg)( INTEGER_ARG(&TBCI) );
   *tbci = (int) TBCI;
}

static void ccpgstbg(int tbci){
   F77_INTEGER_TYPE TBCI;
   TBCI = (F77_INTEGER_TYPE) tbci;
   F77_CALL(pgstbg)( INTEGER_ARG(&TBCI) );
}

static void ccpgqcs(int units, float *xch, float *ych){
   F77_INTEGER_TYPE UNITS;
   F77_REAL_TYPE XCH;
   F77_REAL_TYPE YCH;
   UNITS = (F77_INTEGER_TYPE) units;

   F77_CALL(pgqcs)( INTEGER_ARG(&UNITS), REAL_ARG(&XCH), REAL_ARG(&YCH) );

   *xch = (float) XCH;
   *ych = (float) YCH;
}

static void ccpglen(int units, char *text, float *xl, float *yl ){
   F77_INTEGER_TYPE UNITS;
   F77_REAL_TYPE XL;
   F77_REAL_TYPE YL;
   DECLARE_CHARACTER(LTEXT,MXSTRLEN);
   int ftext_length;

   UNITS = (F77_INTEGER_TYPE) units;


   ftext_length = strlen( text );
   if( ftext_length > LTEXT_length ) ftext_length = LTEXT_length;
   astStringExport( text, LTEXT, ftext_length );

   F77_CALL(pglen)( INTEGER_ARG(&UNITS), CHARACTER_ARG(LTEXT),
                    REAL_ARG(&XL), REAL_ARG(&YL) TRAIL_ARG(ftext) );

   *xl = (float) XL;
   *yl = (float) YL;
}

static void ccpgqvp(int units, float *x1, float *x2, float *y1, float *y2){
   F77_INTEGER_TYPE UNITS;
   F77_REAL_TYPE X1;
   F77_REAL_TYPE X2;
   F77_REAL_TYPE Y1;
   F77_REAL_TYPE Y2;

   UNITS = (F77_INTEGER_TYPE) units;
   F77_CALL(pgqvp)( INTEGER_ARG(&UNITS), REAL_ARG(&X1), REAL_ARG(&X2),
                    REAL_ARG(&Y1), REAL_ARG(&Y2) );
   *x1 = (float) X1;
   *x2 = (float) X2;
   *y1 = (float) Y1;
   *y2 = (float) Y2;
}

static void ccpgqvsz(int units, float *x1, float *x2, float *y1, float *y2){
   F77_INTEGER_TYPE UNITS;
   F77_REAL_TYPE X1;
   F77_REAL_TYPE X2;
   F77_REAL_TYPE Y1;
   F77_REAL_TYPE Y2;

   UNITS = (F77_INTEGER_TYPE) units;
   F77_CALL(pgqvsz)( INTEGER_ARG(&UNITS), REAL_ARG(&X1), REAL_ARG(&X2),
                    REAL_ARG(&Y1), REAL_ARG(&Y2) );
   *x1 = (float) X1;
   *x2 = (float) X2;
   *y1 = (float) Y1;
   *y2 = (float) Y2;
}

static void ccpgqwin(float *x1, float *x2, float *y1, float *y2){
   F77_REAL_TYPE X1;
   F77_REAL_TYPE X2;
   F77_REAL_TYPE Y1;
   F77_REAL_TYPE Y2;

   F77_CALL(pgqwin)( REAL_ARG(&X1), REAL_ARG(&X2), REAL_ARG(&Y1),
                     REAL_ARG(&Y2) );
   *x1 = (float) X1;
   *x2 = (float) X2;
   *y1 = (float) Y1;
   *y2 = (float) Y2;
}

static void ccpgqls(int *ls){
   F77_INTEGER_TYPE LS;
   F77_CALL(pgqls)( INTEGER_ARG(&LS) );
   *ls = (int) LS;
}

static void ccpgsls(int ls){
   F77_INTEGER_TYPE LS;
   LS = (F77_INTEGER_TYPE) ls;
   F77_CALL(pgsls)( INTEGER_ARG(&LS) );
}

static void ccpgqlw(int *lw){
   F77_INTEGER_TYPE LW;
   F77_CALL(pgqlw)( INTEGER_ARG(&LW) );
   *lw = (int) LW;
}

static void ccpgslw(int lw){
   F77_INTEGER_TYPE LW;
   LW = (F77_INTEGER_TYPE) lw;
   F77_CALL(pgslw)( INTEGER_ARG(&LW) );
}

static void ccpgqch(float *ch){
   F77_REAL_TYPE CH;
   F77_CALL(pgqch)( REAL_ARG(&CH) );
   *ch = (float) CH;
}

static void ccpgsch(float ch){
   F77_REAL_TYPE CH;
   CH = (F77_REAL_TYPE) ch;
   F77_CALL(pgsch)( REAL_ARG(&CH) );
}

static void ccpgqcf(int *cf){
   F77_INTEGER_TYPE CF;
   F77_CALL(pgqcf)( INTEGER_ARG(&CF) );
   *cf = (int) CF;
}

static void ccpgscf(int cf){
   F77_INTEGER_TYPE CF;
   CF = (F77_INTEGER_TYPE) cf;
   F77_CALL(pgscf)( INTEGER_ARG(&CF) );
}

static void ccpgqci(int *ci){
   F77_INTEGER_TYPE CI;
   F77_CALL(pgqci)( INTEGER_ARG(&CI) );
   *ci = (int) CI;
}

static void ccpgsci(int ci){
   F77_INTEGER_TYPE CI;
   CI = (F77_INTEGER_TYPE) ci;
   F77_CALL(pgsci)( INTEGER_ARG(&ci) );
}

static void ccpgupdt( void ){
   F77_CALL(pgupdt)();
}

static void ccpgbbuf( void ){
   F77_CALL(pgbbuf)();
}

static void ccpgebuf( void ){
   F77_CALL(pgebuf)();
}