// $Id: plplot_octave.h.in 12372 2013-06-06 21:44:33Z andrewross $
// jc: this is a massaged plplot.h
//
// Copyright (C) 2004  Joao Cardoso
//
// This file is part of PLplot_Octave.
//
// PLplot_Octave is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published
// by the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// PLplot_Octave 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with PLplot_Octave; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//

//
//  Copyright (C) 1992 by
//  Maurice J. LeBrun, Geoff Furnish, Tony Richardson.
//
//  Macros and prototypes for the PLplot package.  This header file must
//  be included by all user codes.
//
//  This software may be freely copied, modified and redistributed
//  without fee provided that this copyright notice is preserved intact
//  on all copies and modified copies.
//
//  There is no warranty or other guarantee of fitness of this software.
//  It is provided solely "as is". The author(s) disclaim(s) all
//  responsibility and liability with respect to this software's usage
//  or its effect upon hardware or computer systems.
//
//  Note: some systems allow the Fortran & C namespaces to clobber each
//  other.  So for PLplot to work from Fortran, we do some rather nasty
//  things to the externally callable C function names.  This shouldn't
//  affect any user programs in C as long as this file is included.
//

#ifndef __PLPLOT_H__
#define __PLPLOT_H__

//--------------------------------------------------------------------------
//    USING PLplot
//
// To use PLplot from C or C++, it is only necessary to
//
//      #include "plplot.h"
//
// This file does all the necessary setup to make PLplot accessible to
// your program as documented in the manual.  Additionally, this file
// allows you to request certain behavior by defining certain symbols
// before inclusion.  At the moment the only one is:
//
// #define DOUBLE	or..
// #define PL_DOUBLE
//
// This causes PLplot to use doubles instead of floats.  Use the type
// PLFLT everywhere in your code, and it will always be the right thing.
//
// Note: most of the functions visible here begin with "pl", while all
// of the data types and switches begin with "PL".  Eventually everything
// will conform to this rule in order to keep namespace pollution of the
// user code to a minimum.  All the PLplot source files actually include
// "plplotP.h", which includes this file as well as all the internally-
// visible declarations, etc.
//--------------------------------------------------------------------------

// The majority of PLplot source files require these, so..
// Under ANSI C, they can be included any number of times.

#include <stdio.h>
#include <stdlib.h>

//--------------------------------------------------------------------------
//        SYSTEM IDENTIFICATION
//
// Several systems are supported directly by PLplot.  In order to avoid
// confusion, one id macro per system is used.  Since different compilers
// may predefine different system id macros, we need to check all the
// possibilities, and then set the one we will be referencing.  These are:
//
// __cplusplus                Any C++ compiler
// __unix                     Any Unix-like system
// __hpux                     Any HP/UX system
// __aix                      Any AIX system
// __linux                    Linux for i386
// (others...)
//
//--------------------------------------------------------------------------

#ifdef unix                     // the old way
#ifndef __unix
#define __unix
#endif
#endif

// Make sure Unix systems define "__unix"

#if defined ( SX ) ||                                   /* NEC Super-UX */ \
    ( defined ( _IBMR2 ) && defined ( _AIX ) ) ||       /* AIX */          \
    defined ( __hpux ) ||                               /* HP/UX */        \
    defined ( sun ) ||                                  /* SUN */          \
    defined ( CRAY ) ||                                 /* Cray */         \
    defined ( __convexc__ ) ||                          /* CONVEX */       \
    ( defined ( __alpha ) && defined ( __osf__ ) )      // DEC Alpha AXP/OSF

#ifndef __unix
#define __unix
#endif
#endif

// A wrapper used in some header files so they can be compiled with cc

#define PLARGS( a )    a

//--------------------------------------------------------------------------
// Base types for PLplot
//
// Only those that are necessary for function prototypes are defined here.
// Notes:
//
// PLINT is typedef'd to an int by default.  This is a change from some
// previous versions, where a long was used.  Under MSDOS, a PLINT is
// typedef'd to a long, since 16 bits is too inaccurate for some PLplot
// functions.  So under MSDOS you must use type PLINT for integer array
// arguments to PLplot functions, but on other systems you can just use
// an int.
//
// short is currently used for device page coordinates, so they are
// bounded by (-32767, 32767).  This gives a max resolution of about 3000
// dpi, and improves performance in some areas over using a PLINT.
//--------------------------------------------------------------------------

@DEFINE_PL_DOUBLE@

#if defined ( PL_DOUBLE ) || defined ( DOUBLE )
typedef double          PLFLT;
#else
typedef float           PLFLT;
#endif

#if defined ( MSDOS )
typedef long            PLINT;
typedef unsigned long   PLUNICODE;
#else
typedef int             PLINT;
typedef unsigned        PLUNICODE;
#endif

// For identifying logical (boolean) arguments
typedef PLINT           PLBOOL;

// For passing user data, as with X's XtPointer

typedef void*           PLPointer;

//--------------------------------------------------------------------------
// Complex data types and other good stuff
//--------------------------------------------------------------------------

// Switches for escape function call.
// Some of these are obsolete but are retained in order to process
// old metafiles

#define PLESC_SET_RGB            1      // obsolete
#define PLESC_ALLOC_NCOL         2      // obsolete
#define PLESC_SET_LPB            3      // obsolete
#define PLESC_EXPOSE             4      // handle window expose
#define PLESC_RESIZE             5      // handle window resize
#define PLESC_REDRAW             6      // handle window redraw
#define PLESC_TEXT               7      // switch to text screen
#define PLESC_GRAPH              8      // switch to graphics screen
#define PLESC_FILL               9      // fill polygon
#define PLESC_DI                 10     // handle DI command
#define PLESC_FLUSH              11     // flush output
#define PLESC_EH                 12     // handle Window events
#define PLESC_GETC               13     // get cursor position
#define PLESC_SWIN               14     // set window parameters
#define PLESC_DOUBLEBUFFERING    15     // configure double buffering
#define PLESC_XORMOD             16     // jc: set xor mode
#define PLESC_SET_COMPRESSION    17     // AFR: set compression
#define PLESC_CLEAR              18     // RL: clear graphics region
#define PLESC_DASH               19     // RL: draw dashed line

// Window parameter tags

#define PLSWIN_DEVICE    1              // device coordinates
#define PLSWIN_WORLD     2              // world coordinates

// PLplot Option table & support constants

// Option-specific settings

#define PL_OPT_ENABLED      0x0001      // Obsolete
#define PL_OPT_ARG          0x0002      // Option has an argment
#define PL_OPT_NODELETE     0x0004      // Don't delete after processing
#define PL_OPT_INVISIBLE    0x0008      // Make invisible
#define PL_OPT_DISABLED     0x0010      // Processing is disabled

// Option-processing settings -- mutually exclusive

#define PL_OPT_FUNC      0x0100         // Call handler function
#define PL_OPT_BOOL      0x0200         // Set *var = 1
#define PL_OPT_INT       0x0400         // Set *var = atoi(optarg)
#define PL_OPT_FLOAT     0x0800         // Set *var = atof(optarg)
#define PL_OPT_STRING    0x1000         // Set var = optarg

// Global mode settings
// These override per-option settings

#define PL_PARSE_PARTIAL      0x0000    // For backward compatibility
#define PL_PARSE_FULL         0x0001    // Process fully & exit if error
#define PL_PARSE_QUIET        0x0002    // Don't issue messages
#define PL_PARSE_NODELETE     0x0004    // Don't delete options after
                                        // processing
#define PL_PARSE_SHOWALL      0x0008    // Show invisible options
#define PL_PARSE_OVERRIDE     0x0010    // Obsolete
#define PL_PARSE_NOPROGRAM    0x0020    // Program name NOT in *argv[0]..
#define PL_PARSE_NODASH       0x0040    // Set if leading dash NOT required
#define PL_PARSE_SKIP         0x0080    // Skip over unrecognized args

// Obsolete names

#define plParseInternalOpts( a, b, c )    plparseopts( a, b, c )
#define plSetInternalOpt( a, b )          plSetOpt( a, b )

// Option table definition

typedef struct
{
    char *opt;
    int ( *handler )( char *, char *, void * );
    void *client_data;
    void *var;
    long mode;
    char *syntax;
    char *desc;
} PLOptionTable;

// PLplot Graphics Input structure

#define PL_MAXKEY    16

typedef struct
{
    int          type;              // of event (CURRENTLY UNUSED)
    unsigned int state;             // key or button mask
    unsigned int keysym;            // key selected
    unsigned int button;            // mouse button selected
    PLINT        subwindow;         // subwindow (alias subpage, alias subplot) number
    char         string[PL_MAXKEY]; // translated string
    int          pX, pY;            // absolute device coordinates of pointer
    PLFLT        dX, dY;            // relative device coordinates of pointer
    PLFLT        wX, wY;            // world coordinates of pointer
} PLGraphicsIn;

// Structure for describing the plot window

#define PL_MAXWINDOWS    64     // Max number of windows/page tracked

typedef struct
{
    PLFLT dxmi, dxma, dymi, dyma;       // min, max window rel dev coords
    PLFLT wxmi, wxma, wymi, wyma;       // min, max window world coords
} PLWindow;

// Structure for doing display-oriented operations via escape commands
// May add other attributes in time

typedef struct
{
    unsigned int x, y;                  // upper left hand corner
    unsigned int width, height;         // window dimensions
} PLDisplay;

// Macro used (in some cases) to ignore value of argument
// I don't plan on changing the value so you can hard-code it

#define PL_NOTSET    ( -42 )

// See plcont.c for examples of the following

//
// PLfGrid is for passing (as a pointer to the first element) an arbitrarily
// dimensioned array.  The grid dimensions MUST be stored, with a maximum of 3
// dimensions assumed for now.
//

typedef struct
{
    PLFLT *f;
    PLINT nx, ny, nz;
} PLfGrid;

//
// PLfGrid2 is for passing (as an array of pointers) a 2d function array.  The
// grid dimensions are passed for possible bounds checking.
//

typedef struct
{
    PLFLT **f;
    PLINT nx, ny;
} PLfGrid2;

//
// NOTE: a PLfGrid3 is a good idea here but there is no way to exploit it yet
// so I'll leave it out for now.
//

//
// PLcGrid is for passing (as a pointer to the first element) arbitrarily
// dimensioned coordinate transformation arrays.  The grid dimensions MUST be
// stored, with a maximum of 3 dimensions assumed for now.
//

typedef struct
{
    PLFLT *xg, *yg, *zg;
    PLINT nx, ny, nz;
} PLcGrid;

//
// PLcGrid2 is for passing (as arrays of pointers) 2d coordinate
// transformation arrays.  The grid dimensions are passed for possible bounds
// checking.
//

typedef struct
{
    PLFLT **xg, **yg, **zg;
    PLINT nx, ny;
} PLcGrid2;

//
// NOTE: a PLcGrid3 is a good idea here but there is no way to exploit it yet
// so I'll leave it out for now.
//

// PLColor is the usual way to pass an rgb color value.

typedef struct
{
    unsigned char r;            // red
    unsigned char g;            // green
    unsigned char b;            // blue
    char          *name;
} PLColor;

// PLControlPt is how cmap1 control points are represented.

typedef struct
{
    PLFLT h;                    // hue
    PLFLT l;                    // lightness
    PLFLT s;                    // saturation
    PLFLT p;                    // position
    int   alt_hue_path;         // if set, interpolate through h=0
} PLControlPt;

// A PLBufferingCB is a control block for interacting with devices
// that support double buffering.

typedef struct
{
    PLINT cmd;
    PLINT result;
} PLBufferingCB;

#define PLESC_DOUBLEBUFFERING_ENABLE     1
#define PLESC_DOUBLEBUFFERING_DISABLE    2
#define PLESC_DOUBLEBUFFERING_QUERY      3


//--------------------------------------------------------------------------
//		BRAINDEAD-ness
//
// Some systems allow the Fortran & C namespaces to clobber each other.
// For PLplot to work from Fortran on these systems, we must name the the
// externally callable C functions something other than their Fortran entry
// names.  In order to make this as easy as possible for the casual user,
// yet reversible to those who abhor my solution, I have done the
// following:
//
//	The C-language bindings are actually different from those
//	described in the manual.  Macros are used to convert the
//	documented names to the names used in this package.  The
//	user MUST include plplot.h in order to get the name
//	redefinition correct.
//
// Sorry to have to resort to such an ugly kludge, but it is really the
// best way to handle the situation at present.  If all available
// compilers offer a way to correct this stupidity, then perhaps we can
// eventually reverse it.
//
// If you feel like screaming at someone (I sure do), please
// direct it at your nearest system vendor who has a braindead shared
// C/Fortran namespace.  Some vendors do offer compiler switches that
// change the object names, but then everybody who wants to use the
// package must throw these same switches, leading to no end of trouble.
//
// Note that this definition should not cause any noticable effects except
// when debugging PLplot calls, in which case you will need to remember
// the real function names (same as before but with a 'c_' prepended).
//
// Also, to avoid macro conflicts, the BRAINDEAD part must not be expanded
// in the stub routines.
//
// Aside: the reason why a shared Fortran/C namespace is deserving of the
// BRAINDEAD characterization is that it completely precludes the the kind
// of universal API that is attempted (more or less) with PLplot, without
// Herculean efforts (e.g. remapping all of the C bindings by macros as
// done here).  The vendors of such a scheme, in order to allow a SINGLE
// type of argument to be passed transparently between C and Fortran,
// namely, a pointer to a conformable data type, have slammed the door on
// insertion of stub routines to handle the conversions needed for other
// data types.  Intelligent linkers could solve this problem, but these are
// not anywhere close to becoming universal.  So meanwhile, one must live
// with either stub routines for the inevitable data conversions, or a
// different API.  The former is what is used here, but is made far more
// difficult in a braindead shared Fortran/C namespace.
//--------------------------------------------------------------------------

#ifndef BRAINDEAD
#define BRAINDEAD
#endif

#ifdef BRAINDEAD

#ifndef __PLSTUBS_H__   // i.e. do not expand this in the stubs

#define    pl_setcontlabelformat    c_pl_setcontlabelformat
#define    pl_setcontlabelparam     c_pl_setcontlabelparam
#define    pladv                    c_pladv
#define    plarc                    c_plarc
#define    plaxes                   c_plaxes
#define    plbin                    c_plbin
#define    plbop                    c_plbop
#define    plbox                    c_plbox
#define    plbox3                   c_plbox3
#define    plbtime                  c_plbtime
#define    plcalc_world             c_plcalc_world
#define    plclear                  c_plclear
#define    plcol0                   c_plcol0
#define    plcol1                   c_plcol1
#define    plconfigtime             c_plconfigtime
#define    plcont                   c_plcont
#define    plcpstrm                 c_plcpstrm
#define    plctime                  c_plctime
#define    plend                    c_plend
#define    plend1                   c_plend1
#define    plenv                    c_plenv
#define    plenv0                   c_plenv0
#define    pleop                    c_pleop
#define    plerrx                   c_plerrx
#define    plerry                   c_plerry
#define    plfamadv                 c_plfamadv
#define    plfill                   c_plfill
#define    plfill3                  c_plfill3
#define    plflush                  c_plflush
#define    plfont                   c_plfont
#define    plfontld                 c_plfontld
#define    plgchr                   c_plgchr
#define    plgcol0                  c_plgcol0
#define    plgcol0a                 c_plgcol0a
#define    plgcolbg                 c_plgcolbg
#define    plgcolbga                c_plgcolbga
#define    plgcompression           c_plgcompression
#define    plgdev                   c_plgdev
#define    plgdidev                 c_plgdidev
#define    plgdiori                 c_plgdiori
#define    plgdiplt                 c_plgdiplt
#define    plgfam                   c_plgfam
#define    plgfci                   c_plgfci
#define    plgfnam                  c_plgfnam
#define    plgfont                  c_plgfont
#define    plglevel                 c_plglevel
#define    plgpage                  c_plgpage
#define    plgra                    c_plgra
#define    plgradient               c_plgradient
#define    plgriddata               c_plgriddata
#define    plgspa                   c_plgspa
#define    plgstrm                  c_plgstrm
#define    plgver                   c_plgver
#define    plgvpd                   c_plgvpd
#define    plgvpw                   c_plgvpw
#define    plgxax                   c_plgxax
#define    plgyax                   c_plgyax
#define    plgzax                   c_plgzax
#define    plhist                   c_plhist
#define    plhls                    c_plhls
#define    plhlsrgb                 c_plhlsrgb
#define    plimage                  c_plimage
#define    plimagefr                c_plimagefr
#define    plinit                   c_plinit
#define    pljoin                   c_pljoin
#define    pllab                    c_pllab
#define    pllightsource            c_pllightsource
#define    plline                   c_plline
#define    plline3                  c_plline3
#define    pllsty                   c_pllsty
#define    plmesh                   c_plmesh
#define    plmeshc                  c_plmeshc
#define    plmkstrm                 c_plmkstrm
#define    plmtex                   c_plmtex
#define    plmtex3                  c_plmtex3
#define    plot3d                   c_plot3d
#define    plot3dc                  c_plot3dc
#define    plparseopts              c_plparseopts
#define    plpat                    c_plpat
#define    plpoin                   c_plpoin
#define    plpoin3                  c_plpoin3
#define    plpoly3                  c_plpoly3
#define    plprec                   c_plprec
#define    plpsty                   c_plpsty
#define    plptex                   c_plptex
#define    plptex3                  c_plptex3
#define    plrandd                  c_plrandd
#define    plreplot                 c_plreplot
#define    plrgb                    c_plrgb
#define    plrgb1                   c_plrgb1
#define    plrgbhls                 c_plrgbhls
#define    plschr                   c_plschr
#define    plscmap0                 c_plscmap0
#define    plscmap0a                c_plscmap0a
#define    plscmap0n                c_plscmap0n
#define    plscmap1                 c_plscmap1
#define    plscmap1a                c_plscmap1a
#define    plscmap1l                c_plscmap1l
#define    plscmap1la               c_plscmap1la
#define    plscmap1n                c_plscmap1n
#define    plscol0                  c_plscol0
#define    plscol0a                 c_plscol0a
#define    plscolbg                 c_plscolbg
#define    plscolbga                c_plscolbga
#define    plscolor                 c_plscolor
#define    plscompression           c_plscompression
#define    plsdev                   c_plsdev
#define    plsdidev                 c_plsdidev
#define    plsdimap                 c_plsdimap
#define    plsdiori                 c_plsdiori
#define    plsdiplt                 c_plsdiplt
#define    plsdiplz                 c_plsdiplz
#define    plseed                   c_plseed
#define    plsesc                   c_plsesc
#define    plsfam                   c_plsfam
#define    plsfci                   c_plsfci
#define    plsfnam                  c_plsfnam
#define    plsfont                  c_plsfont
#define    plshades                 c_plshades
#define    plshade                  c_plshade
#define    plshade1                 c_plshade1
#define    plslabelfunc             c_plslabelfunc
#define    plsmaj                   c_plsmaj
#define    plsmin                   c_plsmin
#define    plsori                   c_plsori
#define    plspage                  c_plspage
#define    plspal0                  c_plspal0
#define    plspal1                  c_plspal1
#define    plspause                 c_plspause
#define    plsstrm                  c_plsstrm
#define    plssub                   c_plssub
#define    plssym                   c_plssym
#define    plstar                   c_plstar
#define    plstart                  c_plstart
#define    plstripa                 c_plstripa
#define    plstripc                 c_plstripc
#define    plstripd                 c_plstripd
#define    plstyl                   c_plstyl
#define    plsurf3d                 c_plsurf3d
#define    plsvect                  c_plsvect
#define    plsvpa                   c_plsvpa
#define    plsxax                   c_plsxax
#define    plsyax                   c_plsyax
#define    plsym                    c_plsym
#define    plszax                   c_plszax
#define    pltext                   c_pltext
#define    pltimefmt                c_pltimefmt
#define    plvasp                   c_plvasp
#define    plvect                   c_plvect
#define    plvpas                   c_plvpas
#define    plvpor                   c_plvpor
#define    plvsta                   c_plvsta
#define    plw3d                    c_plw3d
#define    plwidth                  c_plwidth
#define    plwind                   c_plwind
#define    plxormod                 c_plxormod

#endif  // __PLSTUBS_H__

#endif  // BRAINDEAD

// Redefine some old function names for backward compatibility

#ifndef __PLSTUBS_H__   // i.e. do not expand this in the stubs

#define    plclr          pleop
#define    plpage         plbop
#define    plcol          plcol0
#define    plcontf        plfcont
#define    Alloc2dGrid    plAlloc2dGrid
#define    Free2dGrid     plFree2dGrid

#endif // __PLSTUBS_H__

//--------------------------------------------------------------------------
//		Function Prototypes
//--------------------------------------------------------------------------

#ifdef __cplusplus
extern "C" {
#endif

#include "plplot_octave_rej.h"

// All void types

// C routines callable from stub routines come first

// Advance to subpage "page", or to the next one if "page" = 0.

void c_pladv( PLINT page ); //%name pladv

// Plot an arc

void c_plarc( PLFLT x, PLFLT y, PLFLT a, PLFLT b, PLFLT angle1, PLFLT angle2,
              PLFLT rotate, PLBOOL fill ); //%name plarc

// This functions similarly to plbox() except that the origin of the axes
// is placed at the user-specified point (x0, y0).

void c_plaxes( PLFLT x0, PLFLT y0, const char *xopt, PLFLT xtick, PLINT nxsub,
               const char *yopt, PLFLT ytick, PLINT nysub ); //%name plaxes

// Plot a histogram using x to store data values and y to store frequencies

void c_plbin( PLINT nbin, PLFLT *x, PLFLT *y, PLINT center ); //%name plbin //%input x(nbin), y(nbin)

// Start new page.  Should only be used with pleop().

void c_plbop( void ); //%name plbop

// This draws a box around the current viewport.

void c_plbox( const char *xopt, PLFLT xtick, PLINT nxsub,
              const char *yopt, PLFLT ytick, PLINT nysub ); //%name plbox

// This is the 3-d analogue of plbox().

void c_plbox3( const char *xopt, const char *xlabel, PLFLT xtick, PLINT nsubx,
               const char *yopt, const char *ylabel, PLFLT ytick, PLINT nsuby,
               const char *zopt, const char *zlabel, PLFLT ztick, PLINT nsubz ); //%name plbox3

// Calculate broken-down time from continuous time for current stream.
void c_plbtime( PLINT *year, PLINT *month, PLINT *day, PLINT *hour, PLINT *min, PLFLT *sec, PLFLT ctime ); //%name plbtime //%output year, month, day, hour, min, sec

// Start new page.  Should only be used with pleop().


// Set xor mode; 1-enter, 0-leave

void c_plxormod( PLINT mode, PLINT *status ); //%name plxormod //%output status

// Calculate world coordinates and subpage from relative device coordinates.

void c_plcalc_world( PLFLT rx, PLFLT ry, PLFLT *wx, PLFLT *wy, PLINT *window ); //%name plcalc_world //%output wx, wy, window

// Clear current subpage.

void c_plclear( void ); //%name plclear

// Set color, map 0.  Argument is integer between 0 and 15.

void c_plcol0( PLINT icol0 ); //%name plcol0

inline void my_plcol( PLINT icol0 )
{
    c_plcol0( icol0 );
}                         //%name plcol

// Set color, map 1.  Argument is a float between 0. and 1.

void c_plcol1( PLFLT col1 ); //%name plcol1

// Configure transformation between continuous and broken-down time (and
// vice versa) for current stream.
void c_plconfigtime( PLFLT scale, PLFLT offset1, PLFLT offset2, PLINT ccontrol, PLBOOL ifbtime_offset, PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min, PLFLT sec ); //%name plconfigtime

// Identity transformation.

void pltr0( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data );  //%nowrap

// Does linear interpolation from singly dimensioned coord arrays.

void pltr1( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data ); //%nowrap

// Does linear interpolation from doubly dimensioned coord arrays
// (column dominant, as per normal C 2d arrays).

void pltr2( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data ); //%nowrap

// Just like pltr2() but uses pointer arithmetic to get coordinates from
// 2d grid tables.

void pltr2p( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data ); //%nowrap

// One more hack. As it is not possible (and would not be desirable) to pass
// an Octave function to plcont(), I have defined three plcont():
//	plcont uses a defined here xform()
//	plcont0 uses pltr0()
//	plcont1 uses pltr1()
//	plcont2 uses pltr2()
//	plcont2p uses pltr2p()
//
// Also, as plplot expect vectorized bidimensional arrays, I provided a
// f2c, which is a #define that does the necessary conversion.
//

void xform( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data )
{
    *tx = *( (PLFLT *) pltr_data + 0 ) * x + *( (PLFLT *) pltr_data + 1 ) * y + *( (PLFLT *) pltr_data + 2 );
    *ty = *( (PLFLT *) pltr_data + 3 ) * x + *( (PLFLT *) pltr_data + 4 ) * y + *( (PLFLT *) pltr_data + 5 );
}                                                                                                   //%nowrap

// convert from Fortran like arrays (one vector), to C like 2D arrays

#define  f2c( f, ff, nx, ny )                              \
    PLFLT * *ff;                                           \
    ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) );     \
    for ( int i = 0; i < nx; i++ ) {                       \
        ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
        for ( int j = 0; j < ny; j++ )                     \
            *( ff[i] + j ) = *( f + nx * j + i );}

// simpler plcont() for use with xform()

void my_plcont( PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
                PLINT ly, PLFLT *clevel, PLINT nlevel, PLFLT *tr )
{
    f2c( f, ff, nx, ny );
    c_plcont( ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, xform, tr );
}  //%name plcont //%input f(nx,ny), clevel(nlevel), tr(6)

// plcont() for use with pltr0() NOT TESTED

void my_plcont0( PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
                 PLINT ly, PLFLT *clevel, PLINT nlevel )
{
    f2c( f, ff, nx, ny );
    c_plcont( ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr0, NULL );
}  //%name plcont0 //%input f(nx,ny), clevel(nlevel)

// plcont() for use with pltr1()

void my_plcont1( PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
                 PLINT ly, PLFLT *clevel, PLINT nlevel, PLFLT *xg, PLFLT *yg )
{
    PLcGrid grid1;
    grid1.nx = nx;  grid1.ny = ny;
    grid1.xg = xg;  grid1.yg = yg;
    f2c( f, ff, nx, ny );
    c_plcont( ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr1, &grid1 );
}  //%name plcont1 //%input f(nx,ny), clevel(nlevel), xg(nx), yg(ny)

// plcont() for use with pltr2()

void my_plcont2( PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
                 PLINT ly, PLFLT *clevel, PLINT nlevel, PLFLT *xg, PLFLT *yg )
{
    PLcGrid2 grid2;
    f2c( xg, xgg, nx, ny ); f2c( yg, ygg, nx, ny );
    grid2.nx = nx;  grid2.ny = ny;
    grid2.xg = xgg; grid2.yg = ygg;
    f2c( f, ff, nx, ny );
    c_plcont( ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
}  //%name plcont2 //%input f(nx,ny), clevel(nlevel), xg(nx,ny), yg(nx,ny)

// plcont() for use with pltr2p()

void my_plcont2p( PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
                  PLINT ly, PLFLT *clevel, PLINT nlevel, PLFLT *xg, PLFLT *yg )
{
    PLcGrid2 grid2;
    f2c( xg, xgg, nx, ny ); f2c( yg, ygg, nx, ny );
    grid2.nx = nx;  grid2.ny = ny;
    grid2.xg = xgg; grid2.yg = ygg;
    f2c( f, ff, nx, ny );
    c_plcont( ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
}  //%name plcont2p //%input f(nx,ny), clevel(nlevel), xg(nx,ny), yg(nx,ny)

// Copies state parameters from the reference stream to the current stream.

void c_plcpstrm( PLINT iplsr, PLINT flags ); //%name plcpstrm

// Calculate continuous time from broken-down time for current stream.
void c_plctime( PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min, PLFLT sec, PLFLT *ctime );  //%name plctime  //%output ctime

// Converts input values from relative device coordinates to relative plot
// coordinates.

void pldid2pc( PLFLT *xmin, PLFLT *ymin, PLFLT *xmax, PLFLT *ymax );

// Converts input values from relative plot coordinates to relative
// device coordinates.

void pldip2dc( PLFLT *xmin, PLFLT *ymin, PLFLT *xmax, PLFLT *ymax );

// End a plotting session for all open streams.

void c_plend( void ); //%name plend

// End a plotting session for the current stream only.

void c_plend1( void ); //%name plend1

// Simple interface for defining viewport and window.

void c_plenv( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
              PLINT just, PLINT axis ); //%name plenv


void c_plenv0( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
               PLINT just, PLINT axis ); //%name plenv0

// End current page.  Should only be used with plbop().

void c_pleop( void ); //%name pleop

// Plot horizontal error bars (xmin(i),y(i)) to (xmax(i),y(i))

void c_plerrx( PLINT n, PLFLT *xmin, PLFLT *xmax, PLFLT *y ); //%name plerrx //%input xmin(n), xmax(n), y(n)

// Plot vertical error bars (x,ymin(i)) to (x(i),ymax(i))

void c_plerry( PLINT n, PLFLT *x, PLFLT *ymin, PLFLT *ymax );  //%name plerry //%input ymin(n), ymax(n), x(n)

// Advance to the next family file on the next new page

void c_plfamadv( void ); //%name plfamadv

// Pattern fills the polygon bounded by the input points.

void c_plfill( PLINT n, PLFLT *x, PLFLT *y ); //%name plfill //%input x(n), y(n)

// Pattern fills the 3d polygon bounded by the input points.

void c_plfill3( PLINT n, PLFLT *x, PLFLT *y, PLFLT *z ); //%name plfill3 //%input x(n), y(n), z(n)

// Flushes the output stream.  Use sparingly, if at all.

void c_plflush( void ); //%name plflush

// Sets the global font flag to 'ifont'.

void c_plfont( PLINT ifont ); //%name plfont

// Load specified font set.

void c_plfontld( PLINT fnt ); //%name plfontld

// Get character default height and current (scaled) height

void c_plgchr( PLFLT *p_def, PLFLT *p_ht ); //%name plgchr //%output p_def, p_ht

// Returns 8 bit RGB values for given color from color map 0

void c_plgcol0( PLINT icol0, PLINT *r, PLINT *g, PLINT *b ); //%name plgcol0 //%output r, g, b

// Returns 8 bit RGB + alpha values for given color from color map 0

void c_plgcol0a( PLINT icol0, PLINT *r, PLINT *g, PLINT *b, PLFLT *a ); //%name plgcol0a //%output r, g, b, a

// Returns the background color by 8 bit RGB value

void c_plgcolbg( PLINT *r, PLINT *g, PLINT *b ); //%name plgcolbg //%output r, g, b

// Returns the background color by 8 bit RGB + alpha values

void c_plgcolbga( PLINT *r, PLINT *g, PLINT *b, PLFLT *a ); //%name plgcolbga //%output r, g, b, a

// Returns the current compression setting

void c_plgcompression( PLINT *compression ); //%name plgcompression  //%output compression

// Get the current device (keyword) name

void c_plgdev( char *p_dev );      //%name plgdev //%output p_dev(80)

// Retrieve current window into device space

void c_plgdidev( PLFLT *p_mar, PLFLT *p_aspect, PLFLT *p_jx, PLFLT *p_jy ); //%name plgdidev //%output p_mar, p_aspect, p_jx, p_jy

// Get plot orientation

void c_plgdiori( PLFLT *p_rot ); //%name plgdiori //%output p_rot

// Retrieve current window into plot space

void c_plgdiplt( PLFLT *p_xmin, PLFLT *p_ymin, PLFLT *p_xmax, PLFLT *p_ymax ); //%name plgdiplt //%output p_xmin, p_ymin, p_xmax, p_ymax

// Get FCI (font characterization integer)

void c_plgfci( PLUNICODE *pfci ); //%name plgfci //%output pfci

// Get family file parameters

void c_plgfam( PLINT *p_fam, PLINT *p_num, PLINT *p_bmax ); //%name plgfam //%output p_fam, p_num, p_bmax

// Get the (current) output file name.  Must be preallocated to >80 bytes

void c_plgfnam( char *fnam ); //%name plgfnam //%output fnam(80)

// Get the current font family, style and weight

void c_plgfont( PLINT *p_family, PLINT *p_style, PLINT *p_weight ); //%name plgfont //%output p_family, p_style, p_weight

// Get the (current) run level.

void    c_plglevel( PLINT *p_level ); //%name plglevel //%output p_level

// Get output device parameters.

void c_plgpage( PLFLT *p_xp, PLFLT *p_yp, PLINT *p_xleng, PLINT *p_yleng,
                PLINT *p_xoff, PLINT *p_yoff ); //%name plgpage //%output p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff

// Switches to graphics screen.

void c_plgra( void ); //%name plgra

// Draw gradient in polygon.

void c_plgradient( PLINT n, PLFLT *x, PLFLT *y, PLFLT angle ); //%name plgradient //%input x(n), y(n)

void plgriddata( PLFLT *x, PLFLT *y, PLFLT *z, int npts,
                 PLFLT *xg, int nptsx, PLFLT *yg, int nptsy,
                 PLFLT **zg, int type, PLFLT data ); //%nowrap

void my_plgriddata( PLFLT *x, PLFLT *y, PLFLT *z, int npts,
                    PLFLT *xg, int nptsx, PLFLT *yg, int nptsy,
                    PLFLT *zg, int type, PLFLT data )
{
    f2c( zg, zgg, nptsx, nptsy );
    plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
    for ( int i = 0; i < nptsx; i++ )
        for ( int j = 0; j < nptsy; j++ )
            *( zg + nptsx * j + i ) = zgg[i][j];
} //%name plgriddata //%input x(npts), y(npts), z(npts), xg(nptsx), yg(nptsy) //%output zg(nptsx, nptsy)

// type of gridding algorithm for plgriddata()

#define GRID_CSA       1 // Bivariate Cubic Spline approximation
#define GRID_DTLI      2 // Delaunay Triangulation Linear Interpolation
#define GRID_NNI       3 // Natural Neighbors Interpolation
#define GRID_NNIDW     4 // Nearest Neighbors Inverse Distance Weighted
#define GRID_NNLI      5 // Nearest Neighbors Linear Interpolation
#define GRID_NNAIDW    6 // Nearest Neighbors Around Inverse Distance Weighted

// Get subpage boundaries in absolute coordinates

void c_plgspa( PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax ); //%name plgspa //%output xmin, xmax, ymin, ymax

// Get current stream number.

void c_plgstrm( PLINT *p_strm ); //%name plgstrm //%output p_strm

// Get the current library version number

void c_plgver( char *p_ver ); //%output p_ver(20) //%name plgver

// Get viewport boundaries in normalized device coordinates

void c_plgvpd( PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax ); //%name plgvpd //%output p_xmin, p_xmax, p_ymin, p_ymax

// Get viewport boundaries in world coordinates

void c_plgvpw( PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax ); //%name plgvpw //%output p_xmin, p_xmax, p_ymin, p_ymax

// Get x axis labeling parameters

void c_plgxax( PLINT *p_digmax, PLINT *p_digits ); //%name plgxax //%output p_digmax, p_digits

// Get y axis labeling parameters

void c_plgyax( PLINT *p_digmax, PLINT *p_digits ); //%name plgyax //%output p_digmax, p_digits

// Get z axis labeling parameters

void c_plgzax( PLINT *p_digmax, PLINT *p_digits ); //%name plgzax //%output p_digmax, p_digits

// Draws a histogram of n values of a variable in array data[0..n-1]

void c_plhist( PLINT n, PLFLT *data, PLFLT datmin, PLFLT datmax,
               PLINT nbin, PLINT oldwin ); //%name plhist //%input data(n)

// Set current color (map 0) by hue, lightness, and saturation.

void c_plhls( PLFLT h, PLFLT l, PLFLT s ); //%name plhls

// Function for converting between HLS and RGB color space

void c_plhlsrgb( PLFLT h, PLFLT l, PLFLT s, PLFLT *p_r, PLFLT *p_g, PLFLT *p_b ); //%name plhlsrgb //%output p_r, p_g, p_b

// Initializes PLplot, using preset or default options

void c_plinit( void ); //%name plinit

// Draws a line segment from (x1, y1) to (x2, y2).

void c_pljoin( PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2 ); //%name pljoin

// Simple routine for labelling graphs.

void c_pllab( const char *xlabel, const char *ylabel, const char *tlabel ); //%name pllab

// Sets position of the light source

void c_pllightsource( PLFLT x, PLFLT y, PLFLT z ); //%name pllightsource

// Draws line segments connecting a series of points.

void c_plline( PLINT n, PLFLT *x, PLFLT *y ); //%input x(n), y(n) //%name plline

// Draws a line in 3 space.

void c_plline3( PLINT n, PLFLT *x, PLFLT *y, PLFLT *z ); //%name plline3 //%input x(n), y(n), z(n)

// Set line style.

void c_pllsty( PLINT lin ); //%name pllsty

// Plots a mesh representation of the function z[x][y].

void c_plmesh( PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt ); //%nowrap

void my_plmesh( PLFLT *x, PLFLT *y, PLFLT *z, PLINT nx, PLINT ny, PLINT opt )
{
    f2c( z, zz, nx, ny );
    c_plmesh( x, y, zz, nx, ny, opt );
}                                         //%name plmesh //%input x(nx), y(ny), z(nx,ny)

// Plots a mesh representation of the function z[x][y] with contour

void c_plmeshc( PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLFLT *clevel, PLINT nlevel ); //%nowrap

void my_plmeshc( PLFLT *x, PLFLT *y, PLFLT *z, PLINT nx, PLINT ny, PLINT opt, PLFLT *clevel, PLINT nlevel )
{
    f2c( z, zz, nx, ny );
    c_plmeshc( x, y, zz, nx, ny, opt, clevel, nlevel );
}                                                          //%name plmeshc //%input x(nx), y(ny), z(nx,ny), clevel(nlevel)

// Creates a new stream and makes it the default.

void c_plmkstrm( PLINT *p_strm ); //%name plmkstrm //%output p_strm

// Prints out "text" at specified position relative to viewport

void c_plmtex( const char *side, PLFLT disp, PLFLT pos, PLFLT just,
               const char *text ); //%name plmtex

// Prints out "text" at specified position relative to viewport (3D)

void c_plmtex3( const char *side, PLFLT disp, PLFLT pos, PLFLT just,
                const char *text ); //%name plmtex3

// Plots a 3-d representation of the function z[x][y].

void c_plot3d( PLFLT *x, PLFLT *y, PLFLT **z,
               PLINT nx, PLINT ny, PLINT opt, PLINT side ); //%nowrap

void my_plot3d( PLFLT *x, PLFLT *y, PLFLT *z,
                PLINT nx, PLINT ny, PLINT opt, PLINT side )
{
    f2c( z, zz, nx, ny )
    c_plot3d( x, y, zz, nx, ny, opt, side );
} //%name plot3d //%input x(nx), y(ny), z(nx,ny)

// Plots a 3-d representation of the function z[x][y] with contour

void c_plot3dc( PLFLT *x, PLFLT *y, PLFLT **z,
                PLINT nx, PLINT ny, PLINT opt,
                PLFLT *clevel, PLINT nlevel ); //%nowrap

void my_plot3dc( PLFLT *x, PLFLT *y, PLFLT *z,
                 PLINT nx, PLINT ny, PLINT opt,
                 PLFLT *clevel, PLINT nlevel )
{
    f2c( z, zz, nx, ny )
    c_plot3dc( x, y, zz, nx, ny, opt, clevel, nlevel );
} //%name plot3dc //%input x(nx), y(ny), z(nx,ny), clevel(nlevel)

// Plots the 3-d surface representation of the function z[x][y].

void c_plsurf3d( PLFLT *x, PLFLT *y, PLFLT **z,
                 PLINT nx, PLINT ny, PLINT opt, PLFLT *clevel, PLINT nlevel ); //%nowrap

void my_plsurf3d( PLFLT *x, PLFLT *y, PLFLT *z,
                  PLINT nx, PLINT ny, PLINT opt, PLFLT *clevel, PLINT nlevel )
{
    f2c( z, zz, nx, ny )
    c_plsurf3d( x, y, zz, nx, ny, opt, clevel, nlevel );
} //%name plsurf3d //%input x(nx), y(ny), z(nx,ny), clevel(nlevel)

// Set fill pattern directly.

void c_plpat( PLINT nlin, PLINT *inc, PLINT *del ); //%name plpat //%input inc(nlin), del(nlin)

// Plots array y against x for n points using ASCII code "code".

void c_plpoin( PLINT n, PLFLT *x, PLFLT *y, PLINT code ); //%input x(n), y(n) //%name plpoin

// Draws a series of points in 3 space.

void c_plpoin3( PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, PLINT code ); //%name plpoin3 //%input x(n), y(n), z(n)

// Draws a polygon in 3 space.

void c_plpoly3( PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, PLINT *draw, PLINT ifcc ); //%nowrap

void my_plpoly3( PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, PLINT *draw, PLINT clockwise )
{
    c_plpoly3( n, x, y, z, draw, ( 1 - clockwise ) / 2 );
}                                                  //%name plpoly3 //%input x(n), y(n), z(n), draw(4)

// Set the floating point precision (in number of places) in numeric labels.

void c_plprec( PLINT setp, PLINT prec ); //%name plprec

// Set fill pattern, using one of the predefined patterns.

void c_plpsty( PLINT patt ); //%name plpsty

// Prints out "text" at world cooordinate (x,y).

void c_plptex( PLFLT x, PLFLT y, PLFLT dx, PLFLT dy, PLFLT just, const char *text ); //%name plptex

// Prints out "text" at world cooordinate (x,y,z).

void c_plptex3( PLFLT wx, PLFLT wy, PLFLT wz, PLFLT dx, PLFLT dy, PLFLT dz, PLFLT sx, PLFLT sy, PLFLT sz, PLFLT just, const char *text ); //%name plptex3

// Random number generator based on Mersenne Twister.
//    Obtain real random number in range [0,1].

PLFLT c_plrandd( void );  //%name plrandd

// Replays contents of plot buffer to current device/file.

void c_plreplot( void ); //%name plreplot

// Set line color by red, green, blue from  0. to 1.

void c_plrgb( PLFLT r, PLFLT g, PLFLT b ); //%name plrgb

// Set line color by 8 bit RGB values.

void c_plrgb1( PLINT r, PLINT g, PLINT b ); //%name plrgb1

// Function for converting between HLS and RGB color space

void c_plrgbhls( PLFLT r, PLFLT g, PLFLT b, PLFLT *p_h, PLFLT *p_l, PLFLT *p_s ); //%name plrgbhls //%output p_h, p_l, p_s

// Set character height.

void c_plschr( PLFLT def, PLFLT scale ); //%name plschr

// Set number of colors in cmap 0

void c_plscmap0n( PLINT ncol0 ); //%name plscmap0n

// Set number of colors in cmap 1

void c_plscmap1n( PLINT ncol1 ); //%name plscmap1n

// Set color map 0 colors by 8 bit RGB values

void c_plscmap0( PLINT *r, PLINT *g, PLINT *b, PLINT ncol0 ); //%name plscmap0 //%input r(ncol0), g(ncol0), b(ncol0)

// Set color map 1 colors by 8 bit RGB values

void c_plscmap1( PLINT *r, PLINT *g, PLINT *b, PLINT ncol1 ); //%name plscmap1 //%input r(ncol1), g(ncol1), b(ncol1)

// Set color map 1 colors using a piece-wise linear relationship between
// intensity [0,1] (cmap 1 index) and position in HLS or RGB color space.

void c_plscmap1l( PLINT itype, PLINT npts, PLFLT *intensity,
                  PLFLT *coord1, PLFLT *coord2, PLFLT *coord3, PLINT *alt_hue_path );
//%name plscmap1l //%input intensity(npts), coord1(npts), coord2(npts), coord3(npts), alt_hue_path(npts)

// Set a given color from color map 0 by 8 bit RGB value

void c_plscol0( PLINT icol0, PLINT r, PLINT g, PLINT b ); //%name plscol0

// Set the background color by 8 bit RGB value

void c_plscolbg( PLINT r, PLINT g, PLINT b ); //%name plscolbg

// Set color map 0 colors by 8 bit RGB + alpha values

void c_plscmap0a( PLINT *r, PLINT *g, PLINT *b, PLFLT *a, PLINT ncol0 ); //%name plscmap0a //%input r(ncol0), g(ncol0), b(ncol0), a(ncol0)

// Set color map 1 colors by 8 bit RGB + alpha values

void c_plscmap1a( PLINT *r, PLINT *g, PLINT *b, PLFLT *a, PLINT ncol1 ); //%name plscmap1a //%input r(ncol1), g(ncol1), b(ncol1), a(ncol1)

// Set color map 1 colors using a piece-wise linear relationship between
// intensity [0,1] (cmap 1 index) and position in HLS or RGB color space
// and alpha transparency value.

void c_plscmap1la( PLINT itype, PLINT npts, PLFLT *intensity,
                   PLFLT *coord1, PLFLT *coord2, PLFLT *coord3, PLFLT *a, PLINT *alt_hue_path );
//%name plscmap1la //%input intensity(npts), coord1(npts), coord2(npts), coord3(npts), a(npts), alt_hue_path(npts)

// Set a given color from color map 0 by 8 bit RGB + alpha value

void c_plscol0a( PLINT icol0, PLINT r, PLINT g, PLINT b, PLFLT a ); //%name plscol0a

// Set the background color by 8 bit RGB + alpha value

void c_plscolbga( PLINT r, PLINT g, PLINT b, PLFLT a ); //%name plscolbga

// Used to globally turn color output on/off

void c_plscolor( PLINT color ); //%name plscolor

// Set the compression level

void c_plscompression( PLINT compression ); //%name plscompression

// Set the device (keyword) name

void c_plsdev( const char *devname ); //%name plsdev

// Set window into device space using margin, aspect ratio, and
// justification

void c_plsdidev( PLFLT mar, PLFLT aspect, PLFLT jx, PLFLT jy ); //%name plsdidev

// Set up transformation from metafile coordinates.

void c_plsdimap( PLINT dimxmin, PLINT dimxmax, PLINT dimymin, PLINT dimymax,
                 PLFLT dimxpmm, PLFLT dimypmm ); //%name plsdimap

// Set plot orientation, specifying rotation in units of pi/2.

void c_plsdiori( PLFLT rot ); //%name plsdiori

// Set window into plot space

void c_plsdiplt( PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax ); //%name plsdiplt

// Set window into plot space incrementally (zoom)

void c_plsdiplz( PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax ); //%name plsdiplz

// Set seed for internal random number generator

void c_plseed( unsigned s );  //%name plseed

// Set the escape character for text strings.

void c_plsesc( char esc ); //%name plsesc

// set offset and spacing of contour labels

void c_pl_setcontlabelparam( PLFLT offset, PLFLT size, PLFLT spacing, PLINT active ); //%name pl_setcontlabelparam

// set the format of the contour labels

void c_pl_setcontlabelformat( PLINT lexp, PLINT sigdig ); //%name pl_setcontlabelformat

// Set family file parameters

void c_plsfam( PLINT fam, PLINT num, PLINT bmax ); //%name plsfam

// Set FCI (font characterization integer)

void c_plsfci( PLUNICODE fci ); //%name plsfci

// Set the current font family, style and weight

void c_plsfont( PLINT family, PLINT style, PLINT weight ); //%name plsfont


// Set the output file name.

void c_plsfnam( const char *fnam ); //%name plsfnam

// The same as in plcont. I have hardcoded the first function pointer
// to plfill(). The second function pointer will use the same convention
// as in plcont().
//

// the simpler plshade()

void my_plshade( PLFLT *a, PLINT nx, PLINT ny, PLFLT *defined,
                 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
                 PLFLT shade_min, PLFLT shade_max,
                 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
                 PLINT min_color, PLINT min_width,
                 PLINT max_color, PLINT max_width,
                 PLINT rectangular, PLFLT *tr )
{
    f2c( a, aa, nx, ny );
    c_plshade( aa, nx, ny, NULL, left, right, bottom, top,
        shade_min, shade_max, sh_cmap, sh_color, sh_width,
        min_color, min_width, max_color, max_width,
        plfill, rectangular, xform, tr );
}  //%name plshade //%input a(nx, ny), tr(6)

//  plshade() for use with pltr1

void my_plshade1( PLFLT *a, PLINT nx, PLINT ny, const char *defined,
                  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
                  PLFLT shade_min, PLFLT shade_max,
                  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
                  PLINT min_color, PLINT min_width,
                  PLINT max_color, PLINT max_width,
                  PLINT rectangular, PLFLT *xg, PLFLT *yg )
{
    PLcGrid grid1;
    grid1.nx = nx;  grid1.ny = ny;
    grid1.xg = xg;  grid1.yg = yg;
    f2c( a, aa, nx, ny );
    c_plshade( aa, nx, ny, NULL, left, right, bottom, top,
        shade_min, shade_max, sh_cmap, sh_color, sh_width,
        min_color, min_width, max_color, max_width,
        plfill, rectangular, pltr1, &grid1 );
}  //%name plshade1 //%input a(nx, ny), xg(nx), yg(ny)

//  plshade() for use with pltr2

void my_plshade2( PLFLT *a, PLINT nx, PLINT ny, const char *defined,
                  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
                  PLFLT shade_min, PLFLT shade_max,
                  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
                  PLINT min_color, PLINT min_width,
                  PLINT max_color, PLINT max_width,
                  PLINT rectangular, PLFLT *xg, PLFLT *yg )
{
    PLcGrid2 grid2;
    f2c( xg, xgg, nx, ny ); f2c( yg, ygg, nx, ny );
    grid2.nx = nx;  grid2.ny = ny;
    grid2.xg = xgg; grid2.yg = ygg;
    f2c( a, aa, nx, ny );
    c_plshade( aa, nx, ny, NULL, left, right, bottom, top,
        shade_min, shade_max, sh_cmap, sh_color, sh_width,
        min_color, min_width, max_color, max_width,
        plfill, rectangular, pltr2, &grid2 );
}  //%name plshade2 //%input a(nx, ny), xg(nx,ny), yg(nx,ny)

void my_plshades( PLFLT *a, PLINT nx, PLINT ny,
                  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
                  PLFLT *clevel, PLINT nlevel, PLINT fill_width,
                  PLINT cont_color, PLINT cont_width,
                  PLINT rectangular )
{
    f2c( a, aa, nx, ny );
    c_plshades( aa, nx, ny, NULL, left, right, bottom, top,
        clevel, nlevel, fill_width, cont_color, cont_width,
        plfill, rectangular, NULL, NULL );
}  //%name plshades //%input a(nx, ny), clevel(nlevel)

void my_plshadesx( PLFLT *a, PLINT nx, PLINT ny,
                   PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
                   PLFLT *clevel, PLINT nlevel, PLINT fill_width,
                   PLINT cont_color, PLINT cont_width,
                   PLINT rectangular, PLFLT *tr )
{
    f2c( a, aa, nx, ny );
    c_plshades( aa, nx, ny, NULL, left, right, bottom, top,
        clevel, nlevel, fill_width, cont_color, cont_width,
        plfill, rectangular, xform, tr );
}  //%name plshadesx //%input a(nx, ny), clevel(nlevel), tr(6)

void my_plshades1( PLFLT *a, PLINT nx, PLINT ny,
                   PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
                   PLFLT *clevel, PLINT nlevel, PLINT fill_width,
                   PLINT cont_color, PLINT cont_width,
                   PLINT rectangular, PLFLT *xg, PLFLT *yg )
{
    PLcGrid grid1;
    grid1.nx = nx;  grid1.ny = ny;
    grid1.xg = xg;  grid1.yg = yg;

    f2c( a, aa, nx, ny );
    c_plshades( aa, nx, ny, NULL, left, right, bottom, top,
        clevel, nlevel, fill_width, cont_color, cont_width,
        plfill, rectangular, pltr1, &grid1 );
}  //%name plshades1 //%input a(nx, ny), clevel(nlevel), xg(nx), yg(ny)


void my_plshades2( PLFLT *a, PLINT nx, PLINT ny,
                   PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
                   PLFLT *clevel, PLINT nlevel, PLINT fill_width,
                   PLINT cont_color, PLINT cont_width,
                   PLINT rectangular, PLFLT *xg, PLFLT *yg )
{
    PLcGrid2 grid2;
    f2c( xg, xgg, nx, ny ); f2c( yg, ygg, nx, ny );
    grid2.nx = nx;  grid2.ny = ny;
    grid2.xg = xgg; grid2.yg = ygg;
    f2c( a, aa, nx, ny );
    c_plshades( aa, nx, ny, NULL, left, right, bottom, top,
        clevel, nlevel, fill_width, cont_color, cont_width,
        plfill, rectangular, pltr2, &grid2 );
}  //%name plshades2 //%input a(nx, ny), clevel(nlevel), xg(nx,ny), yg(nx,ny)

// Set up lengths of major tick marks.

void c_plsmaj( PLFLT def, PLFLT scale ); //%name plsmaj

// Set up lengths of minor tick marks.

void c_plsmin( PLFLT def, PLFLT scale ); //%name plsmin

// Set orientation.  Must be done before calling plinit.

void c_plsori( PLINT ori ); //%name plsori

// Set output device parameters.  Usually ignored by the driver.

void c_plspage( PLFLT xp, PLFLT yp, PLINT xleng, PLINT yleng,
                PLINT xoff, PLINT yoff ); //%name plspage

// Set the colors for color table 0 from a cmap0 file

void c_plspal0( const char *filename ); //%name plspal0

// Set the colors for color table 1 from a cmap1 file

void c_plspal1( const char *filename, PLINT interpolate ); //%name plspal1

// Set the pause (on end-of-page) status

void c_plspause( PLINT pause ); //%name plspause

// Set stream number.

void c_plsstrm( PLINT strm ); //%name plsstrm

// Set the number of subwindows in x and y

void c_plssub( PLINT nx, PLINT ny ); //%name plssub

// Set symbol height.

void c_plssym( PLFLT def, PLFLT scale ); //%name plssym

// Initialize PLplot, passing in the windows/page settings.

void c_plstar( PLINT nx, PLINT ny ); //%name plstar

// Initialize PLplot, passing the device name and windows/page settings.

void c_plstart( const char *devname, PLINT nx, PLINT ny ); //%name plstart

// Create 1d stripchart

void my_plstripc( int *id, char *xspec, char *yspec,
                  PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
                  PLFLT xlpos, PLFLT ylpos,
                  PLINT y_ascl, PLINT acc,
                  PLINT colbox, PLINT collab,
                  PLINT *colline, PLINT *styline,
                  char *legline1, char *legline2, char *legline3, char *legline4,
                  char *labx, char *laby, char *labtop )
{
    char *legline[4];
    legline[0] = legline1; legline[1] = legline2;
    legline[2] = legline3; legline[3] = legline4;
    c_plstripc( id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
        xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
        labx, laby, labtop );
}         //%novectorize //%name plstripc //%output id //%input colline(4), styline(4)

// Add a point to a stripchart.

void c_plstripa( PLINT id, PLINT pen, PLFLT x, PLFLT y ); //%name plstripa

// Deletes and releases memory used by a stripchart.

void c_plstripd( PLINT id ); //%name plstripd

// Set up a new line style

void c_plstyl( PLINT nms, PLINT *mark, PLINT *space ); //%name plstyl //%input mark(nms), space(nms)

// Set the vector style

void c_plsvect( PLFLT *arrowx, PLFLT *arrowy, PLINT npts, PLBOOL fill ); //%name plsvect //%input arrowx(npts), arrowy(npts)

// Sets the edges of the viewport to the specified absolute coordinates

void c_plsvpa( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax ); //%name plsvpa

// Set x axis labeling parameters

void c_plsxax( PLINT digmax, PLINT digits ); //%name plsxax

// Set inferior X window

void plsxwin( PLINT window_id );

// Set y axis labeling parameters

void c_plsyax( PLINT digmax, PLINT digits ); //%name plsyax

// Plots array y against x for n points using Hershey symbol "code"

void c_plsym( PLINT n, PLFLT *x, PLFLT *y, PLINT code ); //%name plsym //%input x(n), y(n)

// Set z axis labeling parameters

void c_plszax( PLINT digmax, PLINT digits ); //%name plszax

// Switches to text screen.

void c_pltext( void ); //%name pltext

// Set the format for date / time labels.

void c_pltimefmt( const char *fmt ); //%name pltimefmt

// Sets the edges of the viewport with the given aspect ratio, leaving
// room for labels.

void c_plvasp( PLFLT aspect ); //%name plvasp

// Plot an array of vector arrows - uses the same function pointer
// convention as plcont

void my_plvect( PLFLT *u, PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr )
{
    f2c( u, uu, nx, ny );
    f2c( v, vv, nx, ny );
    c_plvect( uu, vv, nx, ny, scale, xform, tr );
}  //%name plvect  //%input u(nx,ny), v(nx,ny), tr(6)

// plvect() for use with pltr1
void my_plvect1( PLFLT *u, PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *xg, PLFLT *yg )
{
    PLcGrid grid1;
    grid1.nx = nx;  grid1.ny = ny;
    grid1.xg = xg;  grid1.yg = yg;
    f2c( u, uu, nx, ny );
    f2c( v, vv, nx, ny );
    c_plvect( uu, vv, nx, ny, scale, pltr1, &grid1 );
}  //%name plvect1  //%input u(nx,ny), v(nx,ny), xg(nx), yg(ny)

// plvect() for use with pltr2
void my_plvect2( PLFLT *u, PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *xg, PLFLT *yg )
{
    PLcGrid2 grid2;
    f2c( xg, xgg, nx, ny );  f2c( yg, ygg, nx, ny );
    grid2.nx = nx;  grid2.ny = ny;
    grid2.xg = xgg;  grid2.yg = ygg;
    f2c( u, uu, nx, ny );
    f2c( v, vv, nx, ny );
    c_plvect( uu, vv, nx, ny, scale, pltr2, &grid2 );
}  //%name plvect2  //%input u(nx,ny), v(nx,ny), xg(nx,ny), yg(nx,ny)


// Creates the largest viewport of the specified aspect ratio that fits
// within the specified normalized subpage coordinates.

void c_plvpas( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT aspect ); //%name plvpas

// Creates a viewport with the specified normalized subpage coordinates.

void c_plvpor( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax ); //%name plvpor

// Defines a "standard" viewport with seven character heights for
// the left margin and four character heights everywhere else.

void c_plvsta( void ); //%name plvsta

// Set up a window for three-dimensional plotting.

void c_plw3d( PLFLT basex, PLFLT basey, PLFLT height, PLFLT xmin0,
              PLFLT xmax0, PLFLT ymin0, PLFLT ymax0, PLFLT zmin0,
              PLFLT zmax0, PLFLT alt, PLFLT az ); //%name plw3d

// Set pen width.

void c_plwidth( PLFLT width ); //%name plwidth

// Set up world coordinates of the viewport boundaries (2d plots).

void c_plwind( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax ); //%name plwind

//--------------------------------------------------------------------------
//		Functions for use from C or C++ only
//--------------------------------------------------------------------------

// Returns a list of file-oriented device names and their menu strings

void plgFileDevs( char ***p_menustr, char ***p_devname, int *p_ndev );  //%nowrap

// Returns a list of all device names and their menu strings

void plgDevs( char ***p_menustr, char ***p_devname, int *p_ndev );  //%nowrap

// Set the variables to be used for storing error info

void plsError( PLINT *errcode, char *errmsg );

// Transformation routines

// Identity transformation for plots from Fortran.

void pltr0f( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data ); //%nowrap

// Does linear interpolation from doubly dimensioned coord arrays
// (row dominant, i.e. Fortran ordering).

void pltr2f( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data ); //%nowrap

// Example linear transformation function for contour plotter.

// jc: defined above. void xform(PLFLT x, PLFLT y, PLFLT * tx, PLFLT * ty);

// Function evaluators

// Does a lookup from a 2d function array.  Array is of type (PLFLT **),
// and is column dominant (normal C ordering).

PLFLT plf2eval2( PLINT ix, PLINT iy, PLPointer plf2eval_data );  //%nowrap

// Does a lookup from a 2d function array.  Array is of type (PLFLT *),
// and is column dominant (normal C ordering).

PLFLT plf2eval( PLINT ix, PLINT iy, PLPointer plf2eval_data );  //%nowrap

// Does a lookup from a 2d function array.  Array is of type (PLFLT *),
// and is row dominant (Fortran ordering).

PLFLT plf2evalr( PLINT ix, PLINT iy, PLPointer plf2eval_data );  //%nowrap

// Command line parsing utilities

// Clear internal option table info structure.

void plClearOpts( void );

// Reset internal option table info structure.

void plResetOpts( void );

// Merge user option table into internal info structure.

int plMergeOpts( PLOptionTable *options, char *name, char **notes );  //%nowrap

// Set the strings used in usage and syntax messages.

void plSetUsage( char *program_string, char *usage_string );

// Process input strings, treating them as an option and argument pair.

int plSetOpt( char *opt, char *optarg );

// Process options list using current options info.

int plparseopts( int *p_argc, char **argv, PLINT mode ); //%novectorize

// Print usage & syntax message.

void plOptUsage( void );

// Miscellaneous

// Set the output file pointer

void plgfile( FILE **p_file );  //%nowrap

// Get the output file pointer

void plsfile( FILE *file );         //%nowrap

// Get the escape character for text strings.

void plgesc( char *p_esc ); //%nowrap

// Front-end to driver escape function.

void pl_cmd( PLINT op, void *ptr );  //%nowrap

// Return full pathname for given file if executable

int plFindName( char *p ); //%nowrap

// Looks for the specified executable file according to usual search path.

char *plFindCommand( char *fn );  //%nowrap

// Gets search name for file by concatenating the dir, subdir, and file
// name, allocating memory as needed.

void plGetName( char *dir, char *subdir, char *filename, char **filespec ); //%nowrap

// Prompts human to input an integer in response to given message.

PLINT plGetInt( char *s );

// Prompts human to input a float in response to given message.

PLFLT plGetFlt( char *s );

// Nice way to allocate space for a vectored 2d grid

// Allocates a block of memory for use as a 2-d grid of PLFLT's.

void plAlloc2dGrid( PLFLT ***f, PLINT nx, PLINT ny ); //%nowrap

// Frees a block of memory allocated with plAlloc2dGrid().

void plFree2dGrid( PLFLT **f, PLINT nx, PLINT ny );  //%nowrap

// Wait for graphics input event and translate to world coordinates

int plGetCursor( PLGraphicsIn *gin ); //%nowrap

int my_plGetCursor( int *state, int *keysym, int *button, char *string, int *pX, int *pY, PLFLT *dX, PLFLT *dY, PLFLT *wX, PLFLT *wY, int *subwin )
{
    PLGraphicsIn gin;
    int          status; status = plGetCursor( &gin );
    *subwin = gin.subwindow; *state = gin.state; *keysym = gin.keysym; *button = gin.button; *string = gin.string[0];
    *pX     = gin.pX; *pY = gin.pY; *dX = gin.dX; *dY = gin.dY; *wX = gin.wX; *wY = gin.wY;
    return status;
} //%name plGetCursor //%output subwin, state, keysym, button, string(1), pX, pY, dX, dY,  wX, wY

// Translates relative device coordinates to world coordinates.

int plTranslateCursor( PLGraphicsIn *gin ); //%nowrap

int my_plTranslateCursor( PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in )
{
    PLGraphicsIn gin;
    int          st;
    gin.dX = x_in; gin.dY = y_in;
    st     = plTranslateCursor( &gin );
    *x     = gin.wX; *y = gin.wY;
    return st;
} //%name plTranslateCursor //%output x, y

void plimage( PLFLT **data, PLINT nx, PLINT ny,
              PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
              PLFLT zmin, PLFLT zmax,
              PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax ); //%nowrap

void my_plimage( PLFLT *a, PLINT nx, PLINT ny,
                 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
                 PLFLT zmin, PLFLT zmax,
                 PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax )
{
    f2c( a, aa, nx, ny );
    plimage( aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
} //%name pplimage //%input a(nx, ny)

// Plot an image with distortion - uses the same function pointer
// convention as plcont

void my_plimagefr( PLFLT *a, PLINT nx, PLINT ny,
                   PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
                   PLFLT zmin, PLFLT zmax,
                   PLFLT valuemin, PLFLT valuemax )
{
    f2c( a, aa, nx, ny );
    plimagefr( aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
}  //%name plimagefr  //%input a(nx,ny)

void my_plimagefrx( PLFLT *a, PLINT nx, PLINT ny,
                    PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
                    PLFLT zmin, PLFLT zmax,
                    PLFLT valuemin, PLFLT valuemax, PLFLT *tr )
{
    f2c( a, aa, nx, ny );
    plimagefr( aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, xform, tr );
}  //%name plimagefrx  //%input a(nx,ny), tr(6)

// plimagefr() for use with pltr1
void my_plimagefr1( PLFLT *a, PLINT nx, PLINT ny,
                    PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
                    PLFLT zmin, PLFLT zmax,
                    PLFLT valuemin, PLFLT valuemax, PLFLT *xg, PLFLT *yg )
{
    PLcGrid grid1;
    grid1.nx = nx + 1;  grid1.ny = ny + 1;
    grid1.xg = xg;  grid1.yg = yg;
    f2c( a, aa, nx, ny );
    c_plimagefr( aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr1, &grid1 );
}  //%name plimagefr1  //%input a(nx,ny), xg(nx+1), yg(ny+1)

// plimagefr() for use with pltr2
void my_plimagefr2( PLFLT *a, PLINT nx, PLINT ny,
                    PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
                    PLFLT zmin, PLFLT zmax,
                    PLFLT valuemin, PLFLT valuemax, PLFLT *xg, PLFLT *yg )
{
    PLcGrid2 grid2;
    f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );  f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
    grid2.nx = nx + 1;  grid2.ny = ny + 1;
    grid2.xg = xgg;  grid2.yg = ygg;
    f2c( a, aa, nx, ny );
    c_plimagefr( aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr2, &grid2 );
}  //%name plimagefr2  //%input a(nx,ny), xg(nx+1,ny+1), yg(nx+1,ny+1)

void plcolorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
                 PLINT opt, PLINT position, PLFLT x, PLFLT y,
                 PLFLT x_length, PLFLT y_length,
                 PLINT bg_color, PLINT bb_color, PLINT bb_style,
                 PLFLT low_cap_color, PLFLT high_cap_color,
                 PLINT cont_color, PLFLT cont_width,
                 PLINT n_labels, const PLINT *label_opts, const char * const *label,
                 PLINT n_axes, const char * const * axis_opts,
                 const PLFLT *ticks, const PLINT *sub_ticks,
                 const PLINT *n_values, const PLFLT * const *values ) // %nowrap

void my_plcolorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
                    PLINT opt, PLINT position, PLFLT x, PLFLT y,
                    PLFLT x_length, PLFLT y_length,
                    PLINT bg_color, PLINT bb_color, PLINT bb_style,
                    PLFLT low_cap_color, PLFLT high_cap_color,
                    PLINT cont_color, PLFLT cont_width,
                    PLINT n_labels, const PLINT *label_opts, const char * const *label,
                    PLINT nx, const char * const * axis_opts,
                    const PLFLT *ticks, const PLINT *sub_ticks,
                    const PLINT *n_values, const PLFLT *a )
{
    PLINT ny, i;
    ny = -1;
    for ( i = 0; i < nx; i++ )
        if ( n_values[i] < ny )
            ny = n_values[i];
    f2c( a, aa, nx, ny );
    c_plcolorbar( p_colorbar_width, p_colorbar_height,
        opt, position, x, y,
        x_length, y_length,
        bg_color, bb_color, bb_style,
        low_cap_color, high_cap_color,
        cont_color, cont_width,
        n_labels, label_opts, label,
        nx, axis_opts,
        ticks, sub_ticks,
        n_values, aa );
} //%name plcolorbar  //%input a(nx,ny)

#ifdef __cplusplus
}
#endif

#endif  // __PLPLOT_H__

