• Main Page
  • Namespaces
  • Classes
  • Files
  • File List
  • File Members

plplot.h

Go to the documentation of this file.
00001 // $Id: plplot.h 11887 2011-08-16 19:49:14Z hbabcock $
00002 //
00003 //  Macros and prototypes for the PLplot package.  This header file must
00004 //  be included by all user codes.
00005 //
00006 //  Note: some systems allow the Fortran & C namespaces to clobber each
00007 //  other.  So for PLplot to work from Fortran, we do some rather nasty
00008 //  things to the externally callable C function names.  This shouldn't
00009 //  affect any user programs in C as long as this file is included.
00010 //
00011 //  Copyright (C) 1992  Maurice J. LeBrun, Geoff Furnish, Tony Richardson.
00012 //  Copyright (C) 2004-2010  Alan W. Irwin
00013 //  Copyright (C) 2004  Rafael Laboissiere
00014 //  Copyright (C) 2004  Andrew Ross
00015 //
00016 //  This file is part of PLplot.
00017 //
00018 //  PLplot is free software; you can redistribute it and/or modify
00019 //  it under the terms of the GNU Library General Public License as published
00020 //  by the Free Software Foundation; either version 2 of the License, or
00021 //  (at your option) any later version.
00022 //
00023 //  PLplot is distributed in the hope that it will be useful,
00024 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
00025 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00026 //  GNU Library General Public License for more details.
00027 //
00028 //  You should have received a copy of the GNU Library General Public License
00029 //  along with PLplot; if not, write to the Free Software
00030 //  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00031 //
00032 
00033 #ifndef __PLPLOT_H__
00034 #define __PLPLOT_H__
00035 
00036 #include "plConfig.h"
00037 
00038 //--------------------------------------------------------------------------
00039 //    USING PLplot
00040 //
00041 // To use PLplot from C or C++, it is only necessary to
00042 //
00043 //      #include "plplot.h"
00044 //
00045 // This file does all the necessary setup to make PLplot accessible to
00046 // your program as documented in the manual.  Additionally, this file
00047 // allows you to request certain behavior by defining certain symbols
00048 // before inclusion.  At the moment the only one is:
00049 //
00050 // #define DOUBLE       or..
00051 // #define PL_DOUBLE
00052 //
00053 // This causes PLplot to use doubles instead of floats.  Use the type
00054 // PLFLT everywhere in your code, and it will always be the right thing.
00055 //
00056 // Note: most of the functions visible here begin with "pl", while all
00057 // of the data types and switches begin with "PL".  Eventually everything
00058 // will conform to this rule in order to keep namespace pollution of the
00059 // user code to a minimum.  All the PLplot source files actually include
00060 // "plplotP.h", which includes this file as well as all the internally-
00061 // visible declarations, etc.
00062 //--------------------------------------------------------------------------
00063 
00064 // The majority of PLplot source files require these, so..
00065 // Under ANSI C, they can be included any number of times.
00066 
00067 #include <stdio.h>
00068 #include <stdlib.h>
00069 
00070 //--------------------------------------------------------------------------
00071 //        SYSTEM IDENTIFICATION
00072 //
00073 // Several systems are supported directly by PLplot.  In order to avoid
00074 // confusion, one id macro per system is used.  Since different compilers
00075 // may predefine different system id macros, we need to check all the
00076 // possibilities, and then set the one we will be referencing.  These are:
00077 //
00078 // __cplusplus                Any C++ compiler
00079 // __unix                     Any Unix-like system
00080 // __hpux                     Any HP/UX system
00081 // __aix                      Any AIX system
00082 // __linux                    Linux for i386
00083 // (others...)
00084 //
00085 //--------------------------------------------------------------------------
00086 
00087 #ifdef unix                     // the old way
00088 #ifndef __unix
00089 #define __unix
00090 #endif
00091 #endif
00092 
00093 #if 0
00094 #if defined ( __GNUC__ ) && __GNUC__ > 3
00095 // If gcc 4.x, then turn off all visibility of symbols unless
00096 // specified as visible using PLDLLIMPEXP.
00097 //#pragma GCC visibility push(hidden)
00098 // temporary until issues with above hidden can be sorted out
00099   #pragma GCC visibility push(default)
00100 #endif
00101 #endif
00102 // Make sure Unix systems define "__unix"
00103 
00104 #if defined ( SX ) ||                                 /* NEC Super-UX */      \
00105     ( defined ( _IBMR2 ) && defined ( _AIX ) ) ||     /* AIX */               \
00106     defined ( __hpux ) ||                             /* HP/UX */             \
00107     defined ( sun ) ||                                /* SUN */               \
00108     defined ( CRAY ) ||                               /* Cray */              \
00109     defined ( __convexc__ ) ||                        /* CONVEX */            \
00110     ( defined ( __alpha ) && defined ( __osf__ ) ) || /* DEC Alpha AXP/OSF */ \
00111     defined ( __APPLE__ )                             // Max OS-X
00112 #ifndef __unix
00113 #define __unix
00114 #endif
00115 #endif
00116 
00117 // A wrapper used in some header files so they can be compiled with cc
00118 
00119 #define PLARGS( a )    a
00120 
00121 //--------------------------------------------------------------------------
00122 // dll functions
00123 //--------------------------------------------------------------------------
00124 #include "pldll.h"
00125 
00126 //--------------------------------------------------------------------------
00127 // Base types for PLplot
00128 //
00129 // Only those that are necessary for function prototypes are defined here.
00130 // Notes:
00131 //
00132 // PLINT is typedef'd to a long by default.  This is a change from some
00133 // previous versions, where a int was used.  However, so long as you have
00134 // used type PLINT for integer array arguments as specified by the API,
00135 // this change will be transparent for you.
00136 //
00137 // short is currently used for device page coordinates, so they are
00138 // bounded by (-32767, 32767).  This gives a max resolution of about 3000
00139 // dpi, and improves performance in some areas over using a PLINT.
00140 //
00141 // PLUNICODE should be a 32-bit unsigned integer on all platforms.
00142 // For now, we are using unsigned int for our Linux ix86 unicode experiments,
00143 // but that doesn't guarantee 32 bits exactly on all platforms so this will
00144 // be subject to change.
00145 //--------------------------------------------------------------------------
00146 
00147 #if defined ( PL_DOUBLE ) || defined ( DOUBLE )
00148 typedef double   PLFLT;
00149 #define PLFLT_MAX    DBL_MAX
00150 #define PLFLT_MIN    DBL_MIN
00151 #else
00152 typedef float    PLFLT;
00153 #define PLFLT_MAX    FLT_MAX
00154 #define PLFLT_MIN    FLT_MIN
00155 #endif
00156 
00157 #if ( defined ( PL_HAVE_STDINT_H ) && !defined ( __cplusplus ) ) || \
00158     ( defined ( __cplusplus ) && defined ( PL_HAVE_CXX_STDINT_H ) )
00159 #include <stdint.h>
00160 // This is apparently portable if stdint.h exists.
00161 typedef uint32_t       PLUINT;
00162 typedef int32_t        PLINT;
00163 typedef int64_t        PLINT64;
00164 #define PLINT_MIN    INT32_MIN
00165 #else
00166 // A reasonable back-up in case stdint.h does not exist on the platform.
00167 typedef unsigned int   PLUINT;
00168 typedef int            PLINT;
00169 typedef __int64        PLINT64;
00170 // for Visual C++ 2003 and later INT_MIN must be used, otherwise
00171 //  PLINT_MIN is unsigned and 2147483648 NOT -2147483648, see
00172 //  http://msdn.microsoft.com/en-us/library/4kh09110(VS.71).aspx for
00173 //  details
00174 #if defined ( _MSC_VER ) && _MSC_VER >= 1310
00175   #include <Limits.h>
00176   #define PLINT_MIN    INT_MIN
00177 #else
00178   #define PLINT_MIN    -2147483648
00179 #endif
00180 //
00181 // typedef unsigned int PLUINT;
00182 // typedef int PLINT;
00183 // typedef long long PLINT64;
00184 //
00185 #endif
00186 
00187 // For identifying unicode characters
00188 typedef PLUINT   PLUNICODE;
00189 
00190 // For identifying logical (boolean) arguments
00191 typedef PLINT    PLBOOL;
00192 
00193 // For passing user data, as with X's XtPointer
00194 typedef void*    PLPointer;
00195 
00196 //--------------------------------------------------------------------------
00197 // Complex data types and other good stuff
00198 //--------------------------------------------------------------------------
00199 
00200 // Switches for escape function call.
00201 // Some of these are obsolete but are retained in order to process
00202 // old metafiles
00203 
00204 #define PLESC_SET_RGB            1      // obsolete
00205 #define PLESC_ALLOC_NCOL         2      // obsolete
00206 #define PLESC_SET_LPB            3      // obsolete
00207 #define PLESC_EXPOSE             4      // handle window expose
00208 #define PLESC_RESIZE             5      // handle window resize
00209 #define PLESC_REDRAW             6      // handle window redraw
00210 #define PLESC_TEXT               7      // switch to text screen
00211 #define PLESC_GRAPH              8      // switch to graphics screen
00212 #define PLESC_FILL               9      // fill polygon
00213 #define PLESC_DI                 10     // handle DI command
00214 #define PLESC_FLUSH              11     // flush output
00215 #define PLESC_EH                 12     // handle Window events
00216 #define PLESC_GETC               13     // get cursor position
00217 #define PLESC_SWIN               14     // set window parameters
00218 #define PLESC_DOUBLEBUFFERING    15     // configure double buffering
00219 #define PLESC_XORMOD             16     // set xor mode
00220 #define PLESC_SET_COMPRESSION    17     // AFR: set compression
00221 #define PLESC_CLEAR              18     // RL: clear graphics region
00222 #define PLESC_DASH               19     // RL: draw dashed line
00223 #define PLESC_HAS_TEXT           20     // driver draws text
00224 #define PLESC_IMAGE              21     // handle image
00225 #define PLESC_IMAGEOPS           22     // plimage related operations
00226 #define PLESC_PL2DEVCOL          23     // convert PLColor to device color
00227 #define PLESC_DEV2PLCOL          24     // convert device color to PLColor
00228 #define PLESC_SETBGFG            25     // set BG, FG colors
00229 #define PLESC_DEVINIT            26     // alternate device initialization
00230 #define PLESC_GETBACKEND         27     // get used backend of (wxWidgets) driver
00231 #define PLESC_BEGIN_TEXT         28     // get ready to draw a line of text
00232 #define PLESC_TEXT_CHAR          29     // render a character of text
00233 #define PLESC_CONTROL_CHAR       30     // handle a text control character (super/subscript, etc.)
00234 #define PLESC_END_TEXT           31     // finish a drawing a line of text
00235 #define PLESC_START_RASTERIZE    32     // start rasterized rendering
00236 #define PLESC_END_RASTERIZE      33     // end rasterized rendering
00237 #define PLESC_ARC                34     // render an arc
00238 #define PLESC_GRADIENT           35     // render a gradient
00239 #define PLESC_MODESET            36     // set drawing mode
00240 #define PLESC_MODEGET            37     // get drawing mode
00241 
00242 // Alternative unicode text handling control characters
00243 #define PLTEXT_FONTCHANGE        0      // font change in the text stream
00244 #define PLTEXT_SUPERSCRIPT       1      // superscript in the text stream
00245 #define PLTEXT_SUBSCRIPT         2      // subscript in the text stream
00246 
00247 // image operations
00248 #define ZEROW2B                  1
00249 #define ZEROW2D                  2
00250 #define ONEW2B                   3
00251 #define ONEW2D                   4
00252 
00253 // Window parameter tags
00254 
00255 #define PLSWIN_DEVICE    1              // device coordinates
00256 #define PLSWIN_WORLD     2              // world coordinates
00257 
00258 // Axis label tags
00259 #define PL_X_AXIS        1              // The x-axis
00260 #define PL_Y_AXIS        2              // The y-axis
00261 #define PL_Z_AXIS        3              // The z-axis
00262 
00263 // PLplot Option table & support constants
00264 
00265 // Option-specific settings
00266 
00267 #define PL_OPT_ENABLED      0x0001      // Obsolete
00268 #define PL_OPT_ARG          0x0002      // Option has an argment
00269 #define PL_OPT_NODELETE     0x0004      // Don't delete after processing
00270 #define PL_OPT_INVISIBLE    0x0008      // Make invisible
00271 #define PL_OPT_DISABLED     0x0010      // Processing is disabled
00272 
00273 // Option-processing settings -- mutually exclusive
00274 
00275 #define PL_OPT_FUNC      0x0100         // Call handler function
00276 #define PL_OPT_BOOL      0x0200         // Set *var = 1
00277 #define PL_OPT_INT       0x0400         // Set *var = atoi(optarg)
00278 #define PL_OPT_FLOAT     0x0800         // Set *var = atof(optarg)
00279 #define PL_OPT_STRING    0x1000         // Set var = optarg
00280 
00281 // Global mode settings
00282 // These override per-option settings
00283 
00284 #define PL_PARSE_PARTIAL              0x0000 // For backward compatibility
00285 #define PL_PARSE_FULL                 0x0001 // Process fully & exit if error
00286 #define PL_PARSE_QUIET                0x0002 // Don't issue messages
00287 #define PL_PARSE_NODELETE             0x0004 // Don't delete options after
00288                                              // processing
00289 #define PL_PARSE_SHOWALL              0x0008 // Show invisible options
00290 #define PL_PARSE_OVERRIDE             0x0010 // Obsolete
00291 #define PL_PARSE_NOPROGRAM            0x0020 // Program name NOT in *argv[0]..
00292 #define PL_PARSE_NODASH               0x0040 // Set if leading dash NOT required
00293 #define PL_PARSE_SKIP                 0x0080 // Skip over unrecognized args
00294 
00295 // FCI (font characterization integer) related constants.
00296 #define PL_FCI_MARK                   0x80000000
00297 #define PL_FCI_IMPOSSIBLE             0x00000000
00298 #define PL_FCI_HEXDIGIT_MASK          0xf
00299 #define PL_FCI_HEXPOWER_MASK          0x7
00300 #define PL_FCI_HEXPOWER_IMPOSSIBLE    0xf
00301 // These define hexpower values corresponding to each font attribute.
00302 #define PL_FCI_FAMILY                 0x0
00303 #define PL_FCI_STYLE                  0x1
00304 #define PL_FCI_WEIGHT                 0x2
00305 // These are legal values for font family attribute
00306 #define PL_FCI_SANS                   0x0
00307 #define PL_FCI_SERIF                  0x1
00308 #define PL_FCI_MONO                   0x2
00309 #define PL_FCI_SCRIPT                 0x3
00310 #define PL_FCI_SYMBOL                 0x4
00311 // These are legal values for font style attribute
00312 #define PL_FCI_UPRIGHT                0x0
00313 #define PL_FCI_ITALIC                 0x1
00314 #define PL_FCI_OBLIQUE                0x2
00315 // These are legal values for font weight attribute
00316 #define PL_FCI_MEDIUM                 0x0
00317 #define PL_FCI_BOLD                   0x1
00318 
00319 #ifdef PL_DEPRECATED
00320 
00321 // Obsolete names
00322 
00323 #define plParseInternalOpts( a, b, c )    c_plparseopts( a, b, c )
00324 #define plSetInternalOpt( a, b )          plSetOpt( a, b )
00325 
00326 #endif  // PL_DEPRECATED
00327 
00328 
00329 // Option table definition
00330 
00331 typedef struct
00332 {
00333     const char *opt;
00334     int ( *handler )( const char *, const char *, void * );
00335     void       *client_data;
00336     void       *var;
00337     long       mode;
00338     const char *syntax;
00339     const char *desc;
00340 } PLOptionTable;
00341 
00342 // PLplot Graphics Input structure
00343 
00344 #define PL_MAXKEY    16
00345 
00346 typedef struct
00347 {
00348     int          type;              // of event (CURRENTLY UNUSED)
00349     unsigned int state;             // key or button mask
00350     unsigned int keysym;            // key selected
00351     unsigned int button;            // mouse button selected
00352     PLINT        subwindow;         // subwindow (alias subpage, alias subplot) number
00353     char         string[PL_MAXKEY]; // translated string
00354     int          pX, pY;            // absolute device coordinates of pointer
00355     PLFLT        dX, dY;            // relative device coordinates of pointer
00356     PLFLT        wX, wY;            // world coordinates of pointer
00357 } PLGraphicsIn;
00358 
00359 // Structure for describing the plot window
00360 
00361 #define PL_MAXWINDOWS    64     // Max number of windows/page tracked
00362 
00363 typedef struct
00364 {
00365     PLFLT dxmi, dxma, dymi, dyma;       // min, max window rel dev coords
00366     PLFLT wxmi, wxma, wymi, wyma;       // min, max window world coords
00367 } PLWindow;
00368 
00369 // Structure for doing display-oriented operations via escape commands
00370 // May add other attributes in time
00371 
00372 typedef struct
00373 {
00374     unsigned int x, y;                  // upper left hand corner
00375     unsigned int width, height;         // window dimensions
00376 } PLDisplay;
00377 
00378 // Macro used (in some cases) to ignore value of argument
00379 // I don't plan on changing the value so you can hard-code it
00380 
00381 #define PL_NOTSET    ( -42 )
00382 
00383 // See plcont.c for examples of the following
00384 
00385 //
00386 // PLfGrid is for passing (as a pointer to the first element) an arbitrarily
00387 // dimensioned array.  The grid dimensions MUST be stored, with a maximum of 3
00388 // dimensions assumed for now.
00389 //
00390 
00391 typedef struct
00392 {
00393     PLFLT *f;
00394     PLINT nx, ny, nz;
00395 } PLfGrid;
00396 
00397 //
00398 // PLfGrid2 is for passing (as an array of pointers) a 2d function array.  The
00399 // grid dimensions are passed for possible bounds checking.
00400 //
00401 
00402 typedef struct
00403 {
00404     PLFLT **f;
00405     PLINT nx, ny;
00406 } PLfGrid2;
00407 
00408 //
00409 // NOTE: a PLfGrid3 is a good idea here but there is no way to exploit it yet
00410 // so I'll leave it out for now.
00411 //
00412 
00413 //
00414 // PLcGrid is for passing (as a pointer to the first element) arbitrarily
00415 // dimensioned coordinate transformation arrays.  The grid dimensions MUST be
00416 // stored, with a maximum of 3 dimensions assumed for now.
00417 //
00418 
00419 typedef struct
00420 {
00421     PLFLT *xg, *yg, *zg;
00422     PLINT nx, ny, nz;
00423 } PLcGrid;
00424 
00425 //
00426 // PLcGrid2 is for passing (as arrays of pointers) 2d coordinate
00427 // transformation arrays.  The grid dimensions are passed for possible bounds
00428 // checking.
00429 //
00430 
00431 typedef struct
00432 {
00433     PLFLT **xg, **yg, **zg;
00434     PLINT nx, ny;
00435 } PLcGrid2;
00436 
00437 //
00438 // NOTE: a PLcGrid3 is a good idea here but there is no way to exploit it yet
00439 // so I'll leave it out for now.
00440 //
00441 
00442 // PLColor is the usual way to pass an rgb color value.
00443 
00444 typedef struct
00445 {
00446     unsigned char r;            // red
00447     unsigned char g;            // green
00448     unsigned char b;            // blue
00449     PLFLT         a;            // alpha (or transparency)
00450     const char    *name;
00451 } PLColor;
00452 
00453 // PLControlPt is how cmap1 control points are represented.
00454 
00455 typedef struct
00456 {
00457     PLFLT h;                    // hue
00458     PLFLT l;                    // lightness
00459     PLFLT s;                    // saturation
00460     PLFLT p;                    // position
00461     PLFLT a;                    // alpha (or transparency)
00462     int   rev;                  // if set, interpolate through h=0
00463 } PLControlPt;
00464 
00465 // A PLBufferingCB is a control block for interacting with devices
00466 // that support double buffering.
00467 
00468 typedef struct
00469 {
00470     PLINT cmd;
00471     PLINT result;
00472 } PLBufferingCB;
00473 
00474 #define PLESC_DOUBLEBUFFERING_ENABLE     1
00475 #define PLESC_DOUBLEBUFFERING_DISABLE    2
00476 #define PLESC_DOUBLEBUFFERING_QUERY      3
00477 
00478 typedef struct
00479 {
00480     PLFLT exp_label_disp;
00481     PLFLT exp_label_pos;
00482     PLFLT exp_label_just;
00483 } PLLabelDefaults;
00484 
00485 //
00486 // typedefs for access methods for arbitrary (i.e. user defined) data storage
00487 //
00488 
00489 //
00490 // This type of struct holds pointers to functions that are used to get, set,
00491 // modify, and test individual 2-D data points referenced by a PLPointer.  How
00492 // the PLPointer is used depends entirely on the functions that implement the
00493 // various operations.  Certain common data representations have predefined
00494 // instances of this structure prepopulated with pointers to predefined
00495 // functions.
00496 //
00497 
00498 typedef struct
00499 {
00500     PLFLT ( *get )( PLPointer p, PLINT ix, PLINT iy );
00501     PLFLT ( *set )( PLPointer p, PLINT ix, PLINT iy, PLFLT z );
00502     PLFLT ( *add )( PLPointer p, PLINT ix, PLINT iy, PLFLT z );
00503     PLFLT ( *sub )( PLPointer p, PLINT ix, PLINT iy, PLFLT z );
00504     PLFLT ( *mul )( PLPointer p, PLINT ix, PLINT iy, PLFLT z );
00505     PLFLT ( *div )( PLPointer p, PLINT ix, PLINT iy, PLFLT z );
00506     PLINT ( *is_nan )( PLPointer p, PLINT ix, PLINT iy );
00507     void ( *minmax )( PLPointer p, PLINT nx, PLINT ny, PLFLT *zmim, PLFLT *zmax );
00508     //
00509     // f2eval is backwards compatible signature for "f2eval" functions that
00510     // existed before plf2ops "operator function families" were used.
00511     //
00512     PLFLT ( *f2eval )( PLINT ix, PLINT iy, PLPointer p );
00513 } plf2ops_t;
00514 
00515 //
00516 // A typedef to facilitate declaration of a pointer to a plfops_t structure.
00517 //
00518 
00519 typedef plf2ops_t * PLF2OPS;
00520 
00521 //--------------------------------------------------------------------------
00522 //              BRAINDEAD-ness
00523 //
00524 // Some systems allow the Fortran & C namespaces to clobber each other.
00525 // For PLplot to work from Fortran on these systems, we must name the the
00526 // externally callable C functions something other than their Fortran entry
00527 // names.  In order to make this as easy as possible for the casual user,
00528 // yet reversible to those who abhor my solution, I have done the
00529 // following:
00530 //
00531 //      The C-language bindings are actually different from those
00532 //      described in the manual.  Macros are used to convert the
00533 //      documented names to the names used in this package.  The
00534 //      user MUST include plplot.h in order to get the name
00535 //      redefinition correct.
00536 //
00537 // Sorry to have to resort to such an ugly kludge, but it is really the
00538 // best way to handle the situation at present.  If all available
00539 // compilers offer a way to correct this stupidity, then perhaps we can
00540 // eventually reverse it.
00541 //
00542 // If you feel like screaming at someone (I sure do), please
00543 // direct it at your nearest system vendor who has a braindead shared
00544 // C/Fortran namespace.  Some vendors do offer compiler switches that
00545 // change the object names, but then everybody who wants to use the
00546 // package must throw these same switches, leading to no end of trouble.
00547 //
00548 // Note that this definition should not cause any noticable effects except
00549 // when debugging PLplot calls, in which case you will need to remember
00550 // the real function names (same as before but with a 'c_' prepended).
00551 //
00552 // Also, to avoid macro conflicts, the BRAINDEAD part must not be expanded
00553 // in the stub routines.
00554 //
00555 // Aside: the reason why a shared Fortran/C namespace is deserving of the
00556 // BRAINDEAD characterization is that it completely precludes the the kind
00557 // of universal API that is attempted (more or less) with PLplot, without
00558 // Herculean efforts (e.g. remapping all of the C bindings by macros as
00559 // done here).  The vendors of such a scheme, in order to allow a SINGLE
00560 // type of argument to be passed transparently between C and Fortran,
00561 // namely, a pointer to a conformable data type, have slammed the door on
00562 // insertion of stub routines to handle the conversions needed for other
00563 // data types.  Intelligent linkers could solve this problem, but these are
00564 // not anywhere close to becoming universal.  So meanwhile, one must live
00565 // with either stub routines for the inevitable data conversions, or a
00566 // different API.  The former is what is used here, but is made far more
00567 // difficult in a braindead shared Fortran/C namespace.
00568 //--------------------------------------------------------------------------
00569 
00570 #ifndef BRAINDEAD
00571 #define BRAINDEAD
00572 #endif
00573 
00574 #ifdef BRAINDEAD
00575 
00576 #ifndef __PLSTUBS_H__   // i.e. do not expand this in the stubs
00577 
00578 #define    pl_setcontlabelformat    c_pl_setcontlabelformat
00579 #define    pl_setcontlabelparam     c_pl_setcontlabelparam
00580 #define    pladv                    c_pladv
00581 #define    plarc                    c_plarc
00582 #define    plaxes                   c_plaxes
00583 #define    plbin                    c_plbin
00584 #define    plbop                    c_plbop
00585 #define    plbox                    c_plbox
00586 #define    plbox3                   c_plbox3
00587 #define    plbtime                  c_plbtime
00588 #define    plcalc_world             c_plcalc_world
00589 #define    plclear                  c_plclear
00590 #define    plcol0                   c_plcol0
00591 #define    plcol1                   c_plcol1
00592 #define    plcolorbar               c_plcolorbar
00593 #define    plconfigtime             c_plconfigtime
00594 #define    plcont                   c_plcont
00595 #define    plcpstrm                 c_plcpstrm
00596 #define    plctime                  c_plctime
00597 #define    plend                    c_plend
00598 #define    plend1                   c_plend1
00599 #define    plenv                    c_plenv
00600 #define    plenv0                   c_plenv0
00601 #define    pleop                    c_pleop
00602 #define    plerrx                   c_plerrx
00603 #define    plerry                   c_plerry
00604 #define    plfamadv                 c_plfamadv
00605 #define    plfill                   c_plfill
00606 #define    plfill3                  c_plfill3
00607 #define    plflush                  c_plflush
00608 #define    plfont                   c_plfont
00609 #define    plfontld                 c_plfontld
00610 #define    plgchr                   c_plgchr
00611 #define    plgcol0                  c_plgcol0
00612 #define    plgcol0a                 c_plgcol0a
00613 #define    plgcolbg                 c_plgcolbg
00614 #define    plgcolbga                c_plgcolbga
00615 #define    plgcompression           c_plgcompression
00616 #define    plgdev                   c_plgdev
00617 #define    plgdidev                 c_plgdidev
00618 #define    plgdiori                 c_plgdiori
00619 #define    plgdiplt                 c_plgdiplt
00620 #define    plgdrawmode              c_plgdrawmode
00621 #define    plgfam                   c_plgfam
00622 #define    plgfci                   c_plgfci
00623 #define    plgfnam                  c_plgfnam
00624 #define    plgfont                  c_plgfont
00625 #define    plglevel                 c_plglevel
00626 #define    plgpage                  c_plgpage
00627 #define    plgra                    c_plgra
00628 #define    plgradient               c_plgradient
00629 #define    plgriddata               c_plgriddata
00630 #define    plgspa                   c_plgspa
00631 #define    plgstrm                  c_plgstrm
00632 #define    plgver                   c_plgver
00633 #define    plgvpd                   c_plgvpd
00634 #define    plgvpw                   c_plgvpw
00635 #define    plgxax                   c_plgxax
00636 #define    plgyax                   c_plgyax
00637 #define    plgzax                   c_plgzax
00638 #define    plhist                   c_plhist
00639 #define    plhls                    c_plhls
00640 #define    plhlsrgb                 c_plhlsrgb
00641 #define    plimage                  c_plimage
00642 #define    plimagefr                c_plimagefr
00643 #define    plinit                   c_plinit
00644 #define    pljoin                   c_pljoin
00645 #define    pllab                    c_pllab
00646 #define    pllegend                 c_pllegend
00647 #define    pllightsource            c_pllightsource
00648 #define    plline                   c_plline
00649 #define    plpath                   c_plpath
00650 #define    plline3                  c_plline3
00651 #define    pllsty                   c_pllsty
00652 #define    plmap                    c_plmap
00653 #define    plmeridians              c_plmeridians
00654 #define    plmesh                   c_plmesh
00655 #define    plmeshc                  c_plmeshc
00656 #define    plmkstrm                 c_plmkstrm
00657 #define    plmtex                   c_plmtex
00658 #define    plmtex3                  c_plmtex3
00659 #define    plot3d                   c_plot3d
00660 #define    plot3dc                  c_plot3dc
00661 #define    plot3dcl                 c_plot3dcl
00662 #define    plparseopts              c_plparseopts
00663 #define    plpat                    c_plpat
00664 #define    plpoin                   c_plpoin
00665 #define    plpoin3                  c_plpoin3
00666 #define    plpoly3                  c_plpoly3
00667 #define    plprec                   c_plprec
00668 #define    plpsty                   c_plpsty
00669 #define    plptex                   c_plptex
00670 #define    plptex3                  c_plptex3
00671 #define    plrandd                  c_plrandd
00672 #define    plreplot                 c_plreplot
00673 #define    plrgb                    c_plrgb
00674 #define    plrgb1                   c_plrgb1
00675 #define    plrgbhls                 c_plrgbhls
00676 #define    plschr                   c_plschr
00677 #define    plscmap0                 c_plscmap0
00678 #define    plscmap0a                c_plscmap0a
00679 #define    plscmap0n                c_plscmap0n
00680 #define    plscmap1                 c_plscmap1
00681 #define    plscmap1a                c_plscmap1a
00682 #define    plscmap1l                c_plscmap1l
00683 #define    plscmap1la               c_plscmap1la
00684 #define    plscmap1n                c_plscmap1n
00685 #define    plscmap1_range           c_plscmap1_range
00686 #define    plgcmap1_range           c_plgcmap1_range
00687 #define    plscol0                  c_plscol0
00688 #define    plscol0a                 c_plscol0a
00689 #define    plscolbg                 c_plscolbg
00690 #define    plscolbga                c_plscolbga
00691 #define    plscolor                 c_plscolor
00692 #define    plscompression           c_plscompression
00693 #define    plsdev                   c_plsdev
00694 #define    plsdidev                 c_plsdidev
00695 #define    plsdimap                 c_plsdimap
00696 #define    plsdiori                 c_plsdiori
00697 #define    plsdiplt                 c_plsdiplt
00698 #define    plsdiplz                 c_plsdiplz
00699 #define    plseed                   c_plseed
00700 #define    plsesc                   c_plsesc
00701 #define    plsetopt                 c_plsetopt
00702 #define    plsfam                   c_plsfam
00703 #define    plsfci                   c_plsfci
00704 #define    plsfnam                  c_plsfnam
00705 #define    plsfont                  c_plsfont
00706 #define    plshade                  c_plshade
00707 #define    plshade1                 c_plshade1
00708 #define    plshades                 c_plshades
00709 #define    plslabelfunc             c_plslabelfunc
00710 #define    plsmaj                   c_plsmaj
00711 #define    plsmem                   c_plsmem
00712 #define    plsmema                  c_plsmema
00713 #define    plsmin                   c_plsmin
00714 #define    plsdrawmode              c_plsdrawmode
00715 #define    plsori                   c_plsori
00716 #define    plspage                  c_plspage
00717 #define    plspal0                  c_plspal0
00718 #define    plspal1                  c_plspal1
00719 #define    plspause                 c_plspause
00720 #define    plsstrm                  c_plsstrm
00721 #define    plssub                   c_plssub
00722 #define    plssym                   c_plssym
00723 #define    plstar                   c_plstar
00724 #define    plstart                  c_plstart
00725 #define    plstransform             c_plstransform
00726 #define    plstring                 c_plstring
00727 #define    plstring3                c_plstring3
00728 #define    plstripa                 c_plstripa
00729 #define    plstripc                 c_plstripc
00730 #define    plstripd                 c_plstripd
00731 #define    plstyl                   c_plstyl
00732 #define    plsurf3d                 c_plsurf3d
00733 #define    plsurf3dl                c_plsurf3dl
00734 #define    plsvect                  c_plsvect
00735 #define    plsvpa                   c_plsvpa
00736 #define    plsxax                   c_plsxax
00737 #define    plsyax                   c_plsyax
00738 #define    plsym                    c_plsym
00739 #define    plszax                   c_plszax
00740 #define    pltext                   c_pltext
00741 #define    pltimefmt                c_pltimefmt
00742 #define    plvasp                   c_plvasp
00743 #define    plvect                   c_plvect
00744 #define    plvpas                   c_plvpas
00745 #define    plvpor                   c_plvpor
00746 #define    plvsta                   c_plvsta
00747 #define    plw3d                    c_plw3d
00748 #define    plwid                    c_plwid
00749 #define    plwind                   c_plwind
00750 #define    plxormod                 c_plxormod
00751 
00752 #endif  // __PLSTUBS_H__
00753 
00754 #endif  // BRAINDEAD
00755 
00756 // Redefine some old function names for backward compatibility
00757 
00758 #ifndef __PLSTUBS_H__   // i.e. do not expand this in the stubs
00759 
00760 #ifdef PL_DEPRECATED
00761 
00762 #define    plclr           pleop
00763 #define    plpage          plbop
00764 #define    plcol           plcol0
00765 #define    plcontf         plfcont
00766 #define    Alloc2dGrid     plAlloc2dGrid
00767 #define    Free2dGrid      plFree2dGrid
00768 #define    MinMax2dGrid    plMinMax2dGrid
00769 #define    plP_gvpd        plgvpd
00770 #define    plP_gvpw        plgvpw
00771 #define    plotsh3d( x, y, z, nx, ny, opt )    plsurf3d( x, y, z, nx, ny, opt, NULL, 0 )
00772 
00773 #endif // PL_DEPRECATED
00774 
00775 #endif // __PLSTUBS_H__
00776 
00777 //--------------------------------------------------------------------------
00778 //              Function Prototypes
00779 //--------------------------------------------------------------------------
00780 
00781 #ifdef __cplusplus
00782 extern "C" {
00783 #endif
00784 
00785 // All void types
00786 
00787 // C routines callable from stub routines come first
00788 
00789 // set the format of the contour labels
00790 
00791 PLDLLIMPEXP void
00792 c_pl_setcontlabelformat( PLINT lexp, PLINT sigdig );
00793 
00794 // set offset and spacing of contour labels
00795 
00796 PLDLLIMPEXP void
00797 c_pl_setcontlabelparam( PLFLT offset, PLFLT size, PLFLT spacing, PLINT active );
00798 
00799 // Advance to subpage "page", or to the next one if "page" = 0.
00800 
00801 PLDLLIMPEXP void
00802 c_pladv( PLINT page );
00803 
00804 // Plot an arc
00805 
00806 PLDLLIMPEXP void
00807 c_plarc( PLFLT x, PLFLT y, PLFLT a, PLFLT b, PLFLT angle1, PLFLT angle2,
00808          PLFLT rotate, PLBOOL fill );
00809 
00810 // This functions similarly to plbox() except that the origin of the axes
00811 // is placed at the user-specified point (x0, y0).
00812 
00813 PLDLLIMPEXP void
00814 c_plaxes( PLFLT x0, PLFLT y0, const char *xopt, PLFLT xtick, PLINT nxsub,
00815           const char *yopt, PLFLT ytick, PLINT nysub );
00816 
00817 // Plot a histogram using x to store data values and y to store frequencies
00818 
00819 // Flags for plbin() - opt argument
00820 #define PL_BIN_DEFAULT     0
00821 #define PL_BIN_CENTRED     1
00822 #define PL_BIN_NOEXPAND    2
00823 #define PL_BIN_NOEMPTY     4
00824 
00825 PLDLLIMPEXP void
00826 c_plbin( PLINT nbin, const PLFLT *x, const PLFLT *y, PLINT opt );
00827 
00828 // Calculate broken-down time from continuous time for current stream.
00829 PLDLLIMPEXP void
00830 c_plbtime( PLINT *year, PLINT *month, PLINT *day, PLINT *hour, PLINT *min, PLFLT *sec, PLFLT ctime );
00831 
00832 // Start new page.  Should only be used with pleop().
00833 
00834 PLDLLIMPEXP void
00835 c_plbop( void );
00836 
00837 // This draws a box around the current viewport.
00838 
00839 PLDLLIMPEXP void
00840 c_plbox( const char *xopt, PLFLT xtick, PLINT nxsub,
00841          const char *yopt, PLFLT ytick, PLINT nysub );
00842 
00843 // This is the 3-d analogue of plbox().
00844 
00845 PLDLLIMPEXP void
00846 c_plbox3( const char *xopt, const char *xlabel, PLFLT xtick, PLINT nsubx,
00847           const char *yopt, const char *ylabel, PLFLT ytick, PLINT nsuby,
00848           const char *zopt, const char *zlabel, PLFLT ztick, PLINT nsubz );
00849 
00850 // Calculate world coordinates and subpage from relative device coordinates.
00851 
00852 PLDLLIMPEXP void
00853 c_plcalc_world( PLFLT rx, PLFLT ry, PLFLT *wx, PLFLT *wy, PLINT *window );
00854 
00855 // Clear current subpage.
00856 
00857 PLDLLIMPEXP void
00858 c_plclear( void );
00859 
00860 // Set color, map 0.  Argument is integer between 0 and 15.
00861 
00862 PLDLLIMPEXP void
00863 c_plcol0( PLINT icol0 );
00864 
00865 // Set color, map 1.  Argument is a float between 0. and 1.
00866 
00867 PLDLLIMPEXP void
00868 c_plcol1( PLFLT col1 );
00869 
00870 // Configure transformation between continuous and broken-down time (and
00871 // vice versa) for current stream.
00872 PLDLLIMPEXP void
00873 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 );
00874 
00875 // Draws a contour plot from data in f(nx,ny).  Is just a front-end to
00876 // plfcont, with a particular choice for f2eval and f2eval_data.
00877 //
00878 
00879 PLDLLIMPEXP void
00880 c_plcont( const PLFLT **f, PLINT nx, PLINT ny, PLINT kx, PLINT lx,
00881           PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel,
00882           void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
00883           PLPointer pltr_data );
00884 
00885 // Draws a contour plot using the function evaluator f2eval and data stored
00886 // by way of the f2eval_data pointer.  This allows arbitrary organizations
00887 // of 2d array data to be used.
00888 //
00889 
00890 PLDLLIMPEXP void
00891 plfcont( PLFLT ( *f2eval )( PLINT, PLINT, PLPointer ),
00892          PLPointer f2eval_data,
00893          PLINT nx, PLINT ny, PLINT kx, PLINT lx,
00894          PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel,
00895          void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
00896          PLPointer pltr_data );
00897 
00898 // Copies state parameters from the reference stream to the current stream.
00899 
00900 PLDLLIMPEXP void
00901 c_plcpstrm( PLINT iplsr, PLBOOL flags );
00902 
00903 // Calculate continuous time from broken-down time for current stream.
00904 PLDLLIMPEXP void
00905 c_plctime( PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min, PLFLT sec, PLFLT *ctime );
00906 
00907 // Converts input values from relative device coordinates to relative plot
00908 // coordinates.
00909 
00910 PLDLLIMPEXP void
00911 pldid2pc( PLFLT *xmin, PLFLT *ymin, PLFLT *xmax, PLFLT *ymax );
00912 
00913 // Converts input values from relative plot coordinates to relative
00914 // device coordinates.
00915 
00916 PLDLLIMPEXP void
00917 pldip2dc( PLFLT *xmin, PLFLT *ymin, PLFLT *xmax, PLFLT *ymax );
00918 
00919 // End a plotting session for all open streams.
00920 
00921 PLDLLIMPEXP void
00922 c_plend( void );
00923 
00924 // End a plotting session for the current stream only.
00925 
00926 PLDLLIMPEXP void
00927 c_plend1( void );
00928 
00929 // Simple interface for defining viewport and window.
00930 
00931 PLDLLIMPEXP void
00932 c_plenv( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
00933          PLINT just, PLINT axis );
00934 
00935 
00936 // similar to plenv() above, but in multiplot mode does not advance the subpage,
00937 // instead the current subpage is cleared
00938 
00939 PLDLLIMPEXP void
00940 c_plenv0( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
00941           PLINT just, PLINT axis );
00942 
00943 // End current page.  Should only be used with plbop().
00944 
00945 PLDLLIMPEXP void
00946 c_pleop( void );
00947 
00948 // Plot horizontal error bars (xmin(i),y(i)) to (xmax(i),y(i))
00949 
00950 PLDLLIMPEXP void
00951 c_plerrx( PLINT n, const PLFLT *xmin, const PLFLT *xmax, const PLFLT *y );
00952 
00953 // Plot vertical error bars (x,ymin(i)) to (x(i),ymax(i))
00954 
00955 PLDLLIMPEXP void
00956 c_plerry( PLINT n, const PLFLT *x, const PLFLT *ymin, const PLFLT *ymax );
00957 
00958 // Advance to the next family file on the next new page
00959 
00960 PLDLLIMPEXP void
00961 c_plfamadv( void );
00962 
00963 // Pattern fills the polygon bounded by the input points.
00964 
00965 PLDLLIMPEXP void
00966 c_plfill( PLINT n, const PLFLT *x, const PLFLT *y );
00967 
00968 // Pattern fills the 3d polygon bounded by the input points.
00969 
00970 PLDLLIMPEXP void
00971 c_plfill3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z );
00972 
00973 // Flushes the output stream.  Use sparingly, if at all.
00974 
00975 PLDLLIMPEXP void
00976 c_plflush( void );
00977 
00978 // Sets the global font flag to 'ifont'.
00979 
00980 PLDLLIMPEXP void
00981 c_plfont( PLINT ifont );
00982 
00983 // Load specified font set.
00984 
00985 PLDLLIMPEXP void
00986 c_plfontld( PLINT fnt );
00987 
00988 // Get character default height and current (scaled) height
00989 
00990 PLDLLIMPEXP void
00991 c_plgchr( PLFLT *p_def, PLFLT *p_ht );
00992 
00993 // Returns 8 bit RGB values for given color from color map 0
00994 
00995 PLDLLIMPEXP void
00996 c_plgcol0( PLINT icol0, PLINT *r, PLINT *g, PLINT *b );
00997 
00998 // Returns 8 bit RGB values for given color from color map 0 and alpha value
00999 
01000 PLDLLIMPEXP void
01001 c_plgcol0a( PLINT icol0, PLINT *r, PLINT *g, PLINT *b, PLFLT *a );
01002 
01003 // Returns the background color by 8 bit RGB value
01004 
01005 PLDLLIMPEXP void
01006 c_plgcolbg( PLINT *r, PLINT *g, PLINT *b );
01007 
01008 // Returns the background color by 8 bit RGB value and alpha value
01009 
01010 PLDLLIMPEXP void
01011 c_plgcolbga( PLINT *r, PLINT *g, PLINT *b, PLFLT *a );
01012 
01013 // Returns the current compression setting
01014 
01015 PLDLLIMPEXP void
01016 c_plgcompression( PLINT *compression );
01017 
01018 // Get the current device (keyword) name
01019 
01020 PLDLLIMPEXP void
01021 c_plgdev( char *p_dev );
01022 
01023 // Retrieve current window into device space
01024 
01025 PLDLLIMPEXP void
01026 c_plgdidev( PLFLT *p_mar, PLFLT *p_aspect, PLFLT *p_jx, PLFLT *p_jy );
01027 
01028 // Get plot orientation
01029 
01030 PLDLLIMPEXP void
01031 c_plgdiori( PLFLT *p_rot );
01032 
01033 // Retrieve current window into plot space
01034 
01035 PLDLLIMPEXP void
01036 c_plgdiplt( PLFLT *p_xmin, PLFLT *p_ymin, PLFLT *p_xmax, PLFLT *p_ymax );
01037 
01038 // Get the drawing mode
01039 
01040 PLDLLIMPEXP PLINT
01041 c_plgdrawmode();
01042 
01043 // Get FCI (font characterization integer)
01044 
01045 PLDLLIMPEXP void
01046 c_plgfci( PLUNICODE *pfci );
01047 
01048 // Get family file parameters
01049 
01050 PLDLLIMPEXP void
01051 c_plgfam( PLINT *p_fam, PLINT *p_num, PLINT *p_bmax );
01052 
01053 // Get the (current) output file name.  Must be preallocated to >80 bytes
01054 
01055 PLDLLIMPEXP void
01056 c_plgfnam( char *fnam );
01057 
01058 // Get the current font family, style and weight
01059 
01060 PLDLLIMPEXP void
01061 c_plgfont( PLINT *p_family, PLINT *p_style, PLINT *p_weight );
01062 
01063 // Get the (current) run level.
01064 
01065 PLDLLIMPEXP void
01066 c_plglevel( PLINT *p_level );
01067 
01068 // Get output device parameters.
01069 
01070 PLDLLIMPEXP void
01071 c_plgpage( PLFLT *p_xp, PLFLT *p_yp,
01072            PLINT *p_xleng, PLINT *p_yleng, PLINT *p_xoff, PLINT *p_yoff );
01073 
01074 // Switches to graphics screen.
01075 
01076 PLDLLIMPEXP void
01077 c_plgra( void );
01078 
01079 // Draw gradient in polygon.
01080 
01081 PLDLLIMPEXP void
01082 c_plgradient( PLINT n, const PLFLT *x, const PLFLT *y, PLFLT angle );
01083 
01084 // grid irregularly sampled data
01085 
01086 PLDLLIMPEXP void
01087 c_plgriddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT npts,
01088               const PLFLT *xg, PLINT nptsx, const PLFLT *yg, PLINT nptsy,
01089               PLFLT **zg, PLINT type, PLFLT data );
01090 
01091 PLDLLIMPEXP void
01092 plfgriddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT npts,
01093              const PLFLT *xg, PLINT nptsx, const PLFLT *yg, PLINT nptsy,
01094              PLF2OPS zops, PLPointer zgp, PLINT type, PLFLT data );
01095 
01096 // type of gridding algorithm for plgriddata()
01097 
01098 #define GRID_CSA       1 // Bivariate Cubic Spline approximation
01099 #define GRID_DTLI      2 // Delaunay Triangulation Linear Interpolation
01100 #define GRID_NNI       3 // Natural Neighbors Interpolation
01101 #define GRID_NNIDW     4 // Nearest Neighbors Inverse Distance Weighted
01102 #define GRID_NNLI      5 // Nearest Neighbors Linear Interpolation
01103 #define GRID_NNAIDW    6 // Nearest Neighbors Around Inverse Distance Weighted
01104 
01105 // Get subpage boundaries in absolute coordinates
01106 
01107 PLDLLIMPEXP void
01108 c_plgspa( PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax );
01109 
01110 // Get current stream number.
01111 
01112 PLDLLIMPEXP void
01113 c_plgstrm( PLINT *p_strm );
01114 
01115 // Get the current library version number
01116 
01117 PLDLLIMPEXP void
01118 c_plgver( char *p_ver );
01119 
01120 // Get viewport boundaries in normalized device coordinates
01121 
01122 PLDLLIMPEXP void
01123 c_plgvpd( PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax );
01124 
01125 // Get viewport boundaries in world coordinates
01126 
01127 PLDLLIMPEXP void
01128 c_plgvpw( PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax );
01129 
01130 // Get x axis labeling parameters
01131 
01132 PLDLLIMPEXP void
01133 c_plgxax( PLINT *p_digmax, PLINT *p_digits );
01134 
01135 // Get y axis labeling parameters
01136 
01137 PLDLLIMPEXP void
01138 c_plgyax( PLINT *p_digmax, PLINT *p_digits );
01139 
01140 // Get z axis labeling parameters
01141 
01142 PLDLLIMPEXP void
01143 c_plgzax( PLINT *p_digmax, PLINT *p_digits );
01144 
01145 // Draws a histogram of n values of a variable in array data[0..n-1]
01146 
01147 // Flags for plhist() - opt argument; note: some flags are passed to
01148 // plbin() for the actual plotting
01149 #define PL_HIST_DEFAULT            0
01150 #define PL_HIST_NOSCALING          1
01151 #define PL_HIST_IGNORE_OUTLIERS    2
01152 #define PL_HIST_NOEXPAND           8
01153 #define PL_HIST_NOEMPTY            16
01154 
01155 PLDLLIMPEXP void
01156 c_plhist( PLINT n, const PLFLT *data, PLFLT datmin, PLFLT datmax,
01157           PLINT nbin, PLINT opt );
01158 
01159 // Functions for converting between HLS and RGB color space
01160 
01161 PLDLLIMPEXP void
01162 c_plhlsrgb( PLFLT h, PLFLT l, PLFLT s, PLFLT *p_r, PLFLT *p_g, PLFLT *p_b );
01163 
01164 // Initializes PLplot, using preset or default options
01165 
01166 PLDLLIMPEXP void
01167 c_plinit( void );
01168 
01169 // Draws a line segment from (x1, y1) to (x2, y2).
01170 
01171 PLDLLIMPEXP void
01172 c_pljoin( PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2 );
01173 
01174 // Simple routine for labelling graphs.
01175 
01176 PLDLLIMPEXP void
01177 c_pllab( const char *xlabel, const char *ylabel, const char *tlabel );
01178 
01179 //flags used for position argument of both pllegend and plcolorbar
01180 #define PL_POSITION_LEFT             0x1
01181 #define PL_POSITION_RIGHT            0x2
01182 #define PL_POSITION_TOP              0x4
01183 #define PL_POSITION_BOTTOM           0x8
01184 #define PL_POSITION_INSIDE           0x10
01185 #define PL_POSITION_OUTSIDE          0x20
01186 #define PL_POSITION_VIEWPORT         0x40
01187 #define PL_POSITION_SUBPAGE          0x80
01188 
01189 // Flags for pllegend.
01190 #define PL_LEGEND_NONE               0x1
01191 #define PL_LEGEND_COLOR_BOX          0x2
01192 #define PL_LEGEND_LINE               0x4
01193 #define PL_LEGEND_SYMBOL             0x8
01194 #define PL_LEGEND_TEXT_LEFT          0x10
01195 #define PL_LEGEND_BACKGROUND         0x20
01196 #define PL_LEGEND_BOUNDING_BOX       0x40
01197 #define PL_LEGEND_ROW_MAJOR          0x80
01198 
01199 // Flags for plcolorbar
01200 #define PL_COLORBAR_LABEL_LEFT       0x1
01201 #define PL_COLORBAR_LABEL_RIGHT      0x2
01202 #define PL_COLORBAR_LABEL_TOP        0x4
01203 #define PL_COLORBAR_LABEL_BOTTOM     0x8
01204 #define PL_COLORBAR_IMAGE            0x10
01205 #define PL_COLORBAR_SHADE            0x20
01206 #define PL_COLORBAR_GRADIENT         0x40
01207 #define PL_COLORBAR_CAP_NONE         0x80
01208 #define PL_COLORBAR_CAP_LOW          0x100
01209 #define PL_COLORBAR_CAP_HIGH         0x200
01210 #define PL_COLORBAR_SHADE_LABEL      0x400
01211 #define PL_COLORBAR_ORIENT_RIGHT     0x800
01212 #define PL_COLORBAR_ORIENT_TOP       0x1000
01213 #define PL_COLORBAR_ORIENT_LEFT      0x2000
01214 #define PL_COLORBAR_ORIENT_BOTTOM    0x4000
01215 #define PL_COLORBAR_BACKGROUND       0x8000
01216 #define PL_COLORBAR_BOUNDING_BOX     0x10000
01217 
01218 // Flags for drawing mode
01219 #define PL_DRAWMODE_UNKNOWN          0x0
01220 #define PL_DRAWMODE_DEFAULT          0x1
01221 #define PL_DRAWMODE_REPLACE          0x2
01222 #define PL_DRAWMODE_XOR              0x4
01223 
01224 // Routine for drawing discrete line, symbol, or cmap0 legends
01225 PLDLLIMPEXP void
01226 c_pllegend( PLFLT *p_legend_width, PLFLT *p_legend_height,
01227             PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT plot_width,
01228             PLINT bg_color, PLINT bb_color, PLINT bb_style,
01229             PLINT nrow, PLINT ncolumn,
01230             PLINT nlegend, const PLINT *opt_array,
01231             PLFLT text_offset, PLFLT text_scale, PLFLT text_spacing,
01232             PLFLT text_justification,
01233             const PLINT *text_colors, const char **text,
01234             const PLINT *box_colors, const PLINT *box_patterns,
01235             const PLFLT *box_scales, const PLINT *box_line_widths,
01236             const PLINT *line_colors, const PLINT *line_styles,
01237             const PLINT *line_widths,
01238             const PLINT *symbol_colors, const PLFLT *symbol_scales,
01239             const PLINT *symbol_numbers, const char **symbols );
01240 
01241 // Routine for drawing continous colour legends
01242 PLDLLIMPEXP void
01243 c_plcolorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
01244               PLINT opt, PLINT position, PLFLT x, PLFLT y,
01245               PLFLT x_length, PLFLT y_length,
01246               PLINT bg_color, PLINT bb_color, PLINT bb_style,
01247               PLFLT low_cap_color, PLFLT high_cap_color,
01248               PLINT cont_color, PLINT cont_width,
01249               PLFLT ticks, PLINT sub_ticks,
01250               const char *axis_opts, const char *label,
01251               PLINT n_values, const PLFLT *values );
01252 
01253 // Sets position of the light source
01254 PLDLLIMPEXP void
01255 c_pllightsource( PLFLT x, PLFLT y, PLFLT z );
01256 
01257 // Draws line segments connecting a series of points.
01258 
01259 PLDLLIMPEXP void
01260 c_plline( PLINT n, const PLFLT *x, const PLFLT *y );
01261 
01262 // Draws a line in 3 space.
01263 
01264 PLDLLIMPEXP void
01265 c_plline3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z );
01266 
01267 // Set line style.
01268 
01269 PLDLLIMPEXP void
01270 c_pllsty( PLINT lin );
01271 
01272 // plot continental outline in world coordinates
01273 
01274 PLDLLIMPEXP void
01275 c_plmap( void ( *mapform )( PLINT, PLFLT *, PLFLT * ), const char *type,
01276          PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat );
01277 
01278 // Plot the latitudes and longitudes on the background.
01279 
01280 PLDLLIMPEXP void
01281 c_plmeridians( void ( *mapform )( PLINT, PLFLT *, PLFLT * ),
01282                PLFLT dlong, PLFLT dlat,
01283                PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat );
01284 
01285 // Plots a mesh representation of the function z[x][y].
01286 
01287 PLDLLIMPEXP void
01288 c_plmesh( const PLFLT *x, const PLFLT *y, const PLFLT **z, PLINT nx, PLINT ny, PLINT opt );
01289 
01290 // Like plmesh, but uses an evaluator function to access z data from zp
01291 
01292 PLDLLIMPEXP void
01293 plfmesh( const PLFLT *x, const PLFLT *y, PLF2OPS zops, PLPointer zp,
01294          PLINT nx, PLINT ny, PLINT opt );
01295 
01296 // Plots a mesh representation of the function z[x][y] with contour
01297 
01298 PLDLLIMPEXP void
01299 c_plmeshc( const PLFLT *x, const PLFLT *y, const PLFLT **z, PLINT nx, PLINT ny, PLINT opt,
01300            const PLFLT *clevel, PLINT nlevel );
01301 
01302 // Like plmeshc, but uses an evaluator function to access z data from zp
01303 
01304 PLDLLIMPEXP void
01305 plfmeshc( const PLFLT *x, const PLFLT *y, PLF2OPS zops, PLPointer zp,
01306           PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel );
01307 
01308 // Creates a new stream and makes it the default.
01309 
01310 PLDLLIMPEXP void
01311 c_plmkstrm( PLINT *p_strm );
01312 
01313 // Prints out "text" at specified position relative to viewport
01314 
01315 PLDLLIMPEXP void
01316 c_plmtex( const char *side, PLFLT disp, PLFLT pos, PLFLT just,
01317           const char *text );
01318 
01319 // Prints out "text" at specified position relative to viewport (3D)
01320 
01321 PLDLLIMPEXP void
01322 c_plmtex3( const char *side, PLFLT disp, PLFLT pos, PLFLT just,
01323            const char *text );
01324 
01325 // Plots a 3-d representation of the function z[x][y].
01326 
01327 PLDLLIMPEXP void
01328 c_plot3d( const PLFLT *x, const PLFLT *y, const PLFLT **z,
01329           PLINT nx, PLINT ny, PLINT opt, PLBOOL side );
01330 
01331 // Like plot3d, but uses an evaluator function to access z data from zp
01332 
01333 PLDLLIMPEXP void
01334 plfplot3d( const PLFLT *x, const PLFLT *y, PLF2OPS zops, PLPointer zp,
01335            PLINT nx, PLINT ny, PLINT opt, PLBOOL side );
01336 
01337 // Plots a 3-d representation of the function z[x][y] with contour.
01338 
01339 PLDLLIMPEXP void
01340 c_plot3dc( const PLFLT *x, const PLFLT *y, const PLFLT **z,
01341            PLINT nx, PLINT ny, PLINT opt,
01342            const PLFLT *clevel, PLINT nlevel );
01343 
01344 // Like plot3dc, but uses an evaluator function to access z data from zp
01345 
01346 PLDLLIMPEXP void
01347 plfplot3dc( const PLFLT *x, const PLFLT *y, PLF2OPS zops, PLPointer zp,
01348             PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel );
01349 
01350 // Plots a 3-d representation of the function z[x][y] with contour and
01351 // y index limits.
01352 
01353 PLDLLIMPEXP void
01354 c_plot3dcl( const PLFLT *x, const PLFLT *y, const PLFLT **z,
01355             PLINT nx, PLINT ny, PLINT opt,
01356             const PLFLT *clevel, PLINT nlevel,
01357             PLINT ixstart, PLINT ixn, const PLINT *indexymin, const PLINT *indexymax );
01358 
01359 // Like plot3dcl, but uses an evaluator function to access z data from zp
01360 
01361 PLDLLIMPEXP void
01362 plfplot3dcl( const PLFLT *x, const PLFLT *y, PLF2OPS zops, PLPointer zp,
01363              PLINT nx, PLINT ny, PLINT opt,
01364              const PLFLT *clevel, PLINT nlevel,
01365              PLINT ixstart, PLINT ixn, const PLINT *indexymin, const PLINT *indexymax );
01366 
01367 //
01368 // definitions for the opt argument in plot3dc() and plsurf3d()
01369 //
01370 // DRAW_LINEX *must* be 1 and DRAW_LINEY *must* be 2, because of legacy code!
01371 //
01372 
01373 #define DRAW_LINEX     ( 1 << 0 )                  // draw lines parallel to the X axis
01374 #define DRAW_LINEY     ( 1 << 1 )                  // draw lines parallel to the Y axis
01375 #define DRAW_LINEXY    ( DRAW_LINEX | DRAW_LINEY ) // draw lines parallel to both the X and Y axis
01376 #define MAG_COLOR      ( 1 << 2 )                  // draw the mesh with a color dependent of the magnitude
01377 #define BASE_CONT      ( 1 << 3 )                  // draw contour plot at bottom xy plane
01378 #define TOP_CONT       ( 1 << 4 )                  // draw contour plot at top xy plane
01379 #define SURF_CONT      ( 1 << 5 )                  // draw contour plot at surface
01380 #define DRAW_SIDES     ( 1 << 6 )                  // draw sides
01381 #define FACETED        ( 1 << 7 )                  // draw outline for each square that makes up the surface
01382 #define MESH           ( 1 << 8 )                  // draw mesh
01383 
01384 //
01385 //  valid options for plot3dc():
01386 //
01387 //  DRAW_SIDES, BASE_CONT, TOP_CONT (not yet),
01388 //  MAG_COLOR, DRAW_LINEX, DRAW_LINEY, DRAW_LINEXY.
01389 //
01390 //  valid options for plsurf3d():
01391 //
01392 //  MAG_COLOR, BASE_CONT, SURF_CONT, FACETED, DRAW_SIDES.
01393 //
01394 
01395 // Set fill pattern directly.
01396 
01397 PLDLLIMPEXP void
01398 c_plpat( PLINT nlin, const PLINT *inc, const PLINT *del );
01399 
01400 // Draw a line connecting two points, accounting for coordinate transforms
01401 
01402 PLDLLIMPEXP void
01403 c_plpath( PLINT n, PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2 );
01404 
01405 // Plots array y against x for n points using ASCII code "code".
01406 
01407 PLDLLIMPEXP void
01408 c_plpoin( PLINT n, const PLFLT *x, const PLFLT *y, PLINT code );
01409 
01410 // Draws a series of points in 3 space.
01411 
01412 PLDLLIMPEXP void
01413 c_plpoin3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT code );
01414 
01415 // Draws a polygon in 3 space.
01416 
01417 PLDLLIMPEXP void
01418 c_plpoly3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, const PLBOOL *draw, PLBOOL ifcc );
01419 
01420 // Set the floating point precision (in number of places) in numeric labels.
01421 
01422 PLDLLIMPEXP void
01423 c_plprec( PLINT setp, PLINT prec );
01424 
01425 // Set fill pattern, using one of the predefined patterns.
01426 
01427 PLDLLIMPEXP void
01428 c_plpsty( PLINT patt );
01429 
01430 // Prints out "text" at world cooordinate (x,y).
01431 
01432 PLDLLIMPEXP void
01433 c_plptex( PLFLT x, PLFLT y, PLFLT dx, PLFLT dy, PLFLT just, const char *text );
01434 
01435 // Prints out "text" at world cooordinate (x,y,z).
01436 
01437 PLDLLIMPEXP void
01438 c_plptex3( PLFLT wx, PLFLT wy, PLFLT wz, PLFLT dx, PLFLT dy, PLFLT dz,
01439            PLFLT sx, PLFLT sy, PLFLT sz, PLFLT just, const char *text );
01440 
01441 // Random number generator based on Mersenne Twister.
01442 // Obtain real random number in range [0,1].
01443 
01444 PLDLLIMPEXP PLFLT
01445 c_plrandd( void );
01446 
01447 // Replays contents of plot buffer to current device/file.
01448 
01449 PLDLLIMPEXP void
01450 c_plreplot( void );
01451 
01452 // Functions for converting between HLS and RGB color space
01453 
01454 PLDLLIMPEXP void
01455 c_plrgbhls( PLFLT r, PLFLT g, PLFLT b, PLFLT *p_h, PLFLT *p_l, PLFLT *p_s );
01456 
01457 // Set character height.
01458 
01459 PLDLLIMPEXP void
01460 c_plschr( PLFLT def, PLFLT scale );
01461 
01462 // Set color map 0 colors by 8 bit RGB values
01463 
01464 PLDLLIMPEXP void
01465 c_plscmap0( const PLINT *r, const PLINT *g, const PLINT *b, PLINT ncol0 );
01466 
01467 // Set color map 0 colors by 8 bit RGB values and alpha values
01468 
01469 PLDLLIMPEXP void
01470 c_plscmap0a( const PLINT *r, const PLINT *g, const PLINT *b, const PLFLT *a, PLINT ncol0 );
01471 
01472 // Set number of colors in cmap 0
01473 
01474 PLDLLIMPEXP void
01475 c_plscmap0n( PLINT ncol0 );
01476 
01477 // Set color map 1 colors by 8 bit RGB values
01478 
01479 PLDLLIMPEXP void
01480 c_plscmap1( const PLINT *r, const PLINT *g, const PLINT *b, PLINT ncol1 );
01481 
01482 // Set color map 1 colors by 8 bit RGB and alpha values
01483 
01484 PLDLLIMPEXP void
01485 c_plscmap1a( const PLINT *r, const PLINT *g, const PLINT *b, const PLFLT *a, PLINT ncol1 );
01486 
01487 // Set color map 1 colors using a piece-wise linear relationship between
01488 // intensity [0,1] (cmap 1 index) and position in HLS or RGB color space.
01489 
01490 PLDLLIMPEXP void
01491 c_plscmap1l( PLBOOL itype, PLINT npts, const PLFLT *intensity,
01492              const PLFLT *coord1, const PLFLT *coord2, const PLFLT *coord3, const PLBOOL *rev );
01493 
01494 // Set color map 1 colors using a piece-wise linear relationship between
01495 // intensity [0,1] (cmap 1 index) and position in HLS or RGB color space.
01496 // Will also linear interpolate alpha values.
01497 
01498 PLDLLIMPEXP void
01499 c_plscmap1la( PLBOOL itype, PLINT npts, const PLFLT *intensity,
01500               const PLFLT *coord1, const PLFLT *coord2, const PLFLT *coord3, const PLFLT *a, const PLBOOL *rev );
01501 
01502 // Set number of colors in cmap 1
01503 
01504 PLDLLIMPEXP void
01505 c_plscmap1n( PLINT ncol1 );
01506 
01507 // Set the color map 1 range used in continuous plots
01508 
01509 PLDLLIMPEXP void
01510 c_plscmap1_range( PLFLT min_color, PLFLT max_color );
01511 
01512 // Get the color map 1 range used in continuous plots
01513 
01514 PLDLLIMPEXP void
01515 c_plgcmap1_range( PLFLT *min_color, PLFLT *max_color );
01516 
01517 // Set a given color from color map 0 by 8 bit RGB value
01518 
01519 PLDLLIMPEXP void
01520 c_plscol0( PLINT icol0, PLINT r, PLINT g, PLINT b );
01521 
01522 // Set a given color from color map 0 by 8 bit RGB value
01523 
01524 PLDLLIMPEXP void
01525 c_plscol0a( PLINT icol0, PLINT r, PLINT g, PLINT b, PLFLT a );
01526 
01527 // Set the background color by 8 bit RGB value
01528 
01529 PLDLLIMPEXP void
01530 c_plscolbg( PLINT r, PLINT g, PLINT b );
01531 
01532 // Set the background color by 8 bit RGB value and alpha value
01533 
01534 PLDLLIMPEXP void
01535 c_plscolbga( PLINT r, PLINT g, PLINT b, PLFLT a );
01536 
01537 // Used to globally turn color output on/off
01538 
01539 PLDLLIMPEXP void
01540 c_plscolor( PLINT color );
01541 
01542 // Set the compression level
01543 
01544 PLDLLIMPEXP void
01545 c_plscompression( PLINT compression );
01546 
01547 // Set the device (keyword) name
01548 
01549 PLDLLIMPEXP void
01550 c_plsdev( const char *devname );
01551 
01552 // Set window into device space using margin, aspect ratio, and
01553 // justification
01554 
01555 PLDLLIMPEXP void
01556 c_plsdidev( PLFLT mar, PLFLT aspect, PLFLT jx, PLFLT jy );
01557 
01558 // Set up transformation from metafile coordinates.
01559 
01560 PLDLLIMPEXP void
01561 c_plsdimap( PLINT dimxmin, PLINT dimxmax, PLINT dimymin, PLINT dimymax,
01562             PLFLT dimxpmm, PLFLT dimypmm );
01563 
01564 // Set plot orientation, specifying rotation in units of pi/2.
01565 
01566 PLDLLIMPEXP void
01567 c_plsdiori( PLFLT rot );
01568 
01569 // Set window into plot space
01570 
01571 PLDLLIMPEXP void
01572 c_plsdiplt( PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax );
01573 
01574 // Set window into plot space incrementally (zoom)
01575 
01576 PLDLLIMPEXP void
01577 c_plsdiplz( PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax );
01578 
01579 // Set seed for internal random number generator
01580 
01581 PLDLLIMPEXP void
01582 c_plseed( unsigned int s );
01583 
01584 // Set the escape character for text strings.
01585 
01586 PLDLLIMPEXP void
01587 c_plsesc( char esc );
01588 
01589 // Set family file parameters
01590 
01591 PLDLLIMPEXP void
01592 c_plsfam( PLINT fam, PLINT num, PLINT bmax );
01593 
01594 // Set FCI (font characterization integer)
01595 
01596 PLDLLIMPEXP void
01597 c_plsfci( PLUNICODE fci );
01598 
01599 // Set the output file name.
01600 
01601 PLDLLIMPEXP void
01602 c_plsfnam( const char *fnam );
01603 
01604 // Set the current font family, style and weight
01605 
01606 PLDLLIMPEXP void
01607 c_plsfont( PLINT family, PLINT style, PLINT weight );
01608 
01609 // Shade region.
01610 
01611 PLDLLIMPEXP void
01612 c_plshade( const PLFLT **a, PLINT nx, PLINT ny, PLINT ( *defined )( PLFLT, PLFLT ),
01613            PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
01614            PLFLT shade_min, PLFLT shade_max,
01615            PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
01616            PLINT min_color, PLINT min_width,
01617            PLINT max_color, PLINT max_width,
01618            void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), PLBOOL rectangular,
01619            void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01620            PLPointer pltr_data );
01621 
01622 PLDLLIMPEXP void
01623 c_plshade1( const PLFLT *a, PLINT nx, PLINT ny, PLINT ( *defined )( PLFLT, PLFLT ),
01624             PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
01625             PLFLT shade_min, PLFLT shade_max,
01626             PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
01627             PLINT min_color, PLINT min_width,
01628             PLINT max_color, PLINT max_width,
01629             void ( *fill )( const PLINT, const PLFLT *, const PLFLT * ), PLBOOL rectangular,
01630             void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01631             PLPointer pltr_data );
01632 
01633 PLDLLIMPEXP void
01634 c_plshades( const PLFLT **a, PLINT nx, PLINT ny, PLINT ( *defined )( PLFLT, PLFLT ),
01635             PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
01636             const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
01637             PLINT cont_color, PLINT cont_width,
01638             void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), PLBOOL rectangular,
01639             void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01640             PLPointer pltr_data );
01641 
01642 PLDLLIMPEXP void
01643 plfshades( PLF2OPS zops, PLPointer zp, PLINT nx, PLINT ny,
01644            PLINT ( *defined )( PLFLT, PLFLT ),
01645            PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
01646            const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
01647            PLINT cont_color, PLINT cont_width,
01648            void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), PLINT rectangular,
01649            void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01650            PLPointer pltr_data );
01651 
01652 PLDLLIMPEXP void
01653 plfshade( PLFLT ( *f2eval )( PLINT, PLINT, PLPointer ),
01654           PLPointer f2eval_data,
01655           PLFLT ( *c2eval )( PLINT, PLINT, PLPointer ),
01656           PLPointer c2eval_data,
01657           PLINT nx, PLINT ny,
01658           PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
01659           PLFLT shade_min, PLFLT shade_max,
01660           PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
01661           PLINT min_color, PLINT min_width,
01662           PLINT max_color, PLINT max_width,
01663           void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), PLBOOL rectangular,
01664           void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01665           PLPointer pltr_data );
01666 
01667 PLDLLIMPEXP void
01668 plfshade1( PLF2OPS zops, PLPointer zp, PLINT nx, PLINT ny,
01669            PLINT ( *defined )( PLFLT, PLFLT ),
01670            PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
01671            PLFLT shade_min, PLFLT shade_max,
01672            PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
01673            PLINT min_color, PLINT min_width,
01674            PLINT max_color, PLINT max_width,
01675            void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), PLINT rectangular,
01676            void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01677            PLPointer pltr_data );
01678 
01679 // Setup a user-provided custom labeling function
01680 
01681 PLDLLIMPEXP void
01682 c_plslabelfunc( void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer ),
01683                 PLPointer label_data );
01684 
01685 // Set up lengths of major tick marks.
01686 
01687 PLDLLIMPEXP void
01688 c_plsmaj( PLFLT def, PLFLT scale );
01689 
01690 // Set the RGB memory area to be plotted (with the 'mem' or 'memcairo' drivers)
01691 
01692 PLDLLIMPEXP void
01693 c_plsmem( PLINT maxx, PLINT maxy, void *plotmem );
01694 
01695 // Set the RGBA memory area to be plotted (with the 'memcairo' driver)
01696 
01697 PLDLLIMPEXP void
01698 c_plsmema( PLINT maxx, PLINT maxy, void *plotmem );
01699 
01700 // Set up lengths of minor tick marks.
01701 
01702 PLDLLIMPEXP void
01703 c_plsmin( PLFLT def, PLFLT scale );
01704 
01705 // Set the drawing mode
01706 PLDLLIMPEXP void
01707 c_plsdrawmode( PLINT mode );
01708 
01709 // Set orientation.  Must be done before calling plinit.
01710 
01711 PLDLLIMPEXP void
01712 c_plsori( PLINT ori );
01713 
01714 // Set output device parameters.  Usually ignored by the driver.
01715 
01716 PLDLLIMPEXP void
01717 c_plspage( PLFLT xp, PLFLT yp, PLINT xleng, PLINT yleng,
01718            PLINT xoff, PLINT yoff );
01719 
01720 // Set the colors for color table 0 from a cmap0 file
01721 
01722 PLDLLIMPEXP void
01723 c_plspal0( const char *filename );
01724 
01725 // Set the colors for color table 1 from a cmap1 file
01726 
01727 PLDLLIMPEXP void
01728 c_plspal1( const char *filename, PLBOOL interpolate );
01729 
01730 // Set the pause (on end-of-page) status
01731 
01732 PLDLLIMPEXP void
01733 c_plspause( PLBOOL pause );
01734 
01735 // Set stream number.
01736 
01737 PLDLLIMPEXP void
01738 c_plsstrm( PLINT strm );
01739 
01740 // Set the number of subwindows in x and y
01741 
01742 PLDLLIMPEXP void
01743 c_plssub( PLINT nx, PLINT ny );
01744 
01745 // Set symbol height.
01746 
01747 PLDLLIMPEXP void
01748 c_plssym( PLFLT def, PLFLT scale );
01749 
01750 // Initialize PLplot, passing in the windows/page settings.
01751 
01752 PLDLLIMPEXP void
01753 c_plstar( PLINT nx, PLINT ny );
01754 
01755 // Initialize PLplot, passing the device name and windows/page settings.
01756 
01757 PLDLLIMPEXP void
01758 c_plstart( const char *devname, PLINT nx, PLINT ny );
01759 
01760 // Set the coordinate transform
01761 
01762 PLDLLIMPEXP void
01763 c_plstransform( void ( *coordinate_transform )( PLFLT, PLFLT, PLFLT*, PLFLT*, PLPointer ), PLPointer coordinate_transform_data );
01764 
01765 // Prints out the same string repeatedly at the n points in world
01766 // coordinates given by the x and y arrays.  Supersedes plpoin and
01767 // plsymbol for the case where text refers to a unicode glyph either
01768 // directly as UTF-8 or indirectly via the standard text escape
01769 // sequences allowed for PLplot input strings.
01770 
01771 PLDLLIMPEXP void
01772 c_plstring( PLINT n, const PLFLT *x, const PLFLT *y, const char *string );
01773 
01774 // Prints out the same string repeatedly at the n points in world
01775 // coordinates given by the x, y, and z arrays.  Supersedes plpoin3
01776 // for the case where text refers to a unicode glyph either directly
01777 // as UTF-8 or indirectly via the standard text escape sequences
01778 // allowed for PLplot input strings.
01779 
01780 PLDLLIMPEXP void
01781 c_plstring3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, const char *string );
01782 
01783 // Add a point to a stripchart.
01784 
01785 PLDLLIMPEXP void
01786 c_plstripa( PLINT id, PLINT pen, PLFLT x, PLFLT y );
01787 
01788 // Create 1d stripchart
01789 
01790 PLDLLIMPEXP void
01791 c_plstripc( PLINT *id, const char *xspec, const char *yspec,
01792             PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
01793             PLFLT xlpos, PLFLT ylpos,
01794             PLBOOL y_ascl, PLBOOL acc,
01795             PLINT colbox, PLINT collab,
01796             const PLINT colline[], const PLINT styline[], const char *legline[],
01797             const char *labx, const char *laby, const char *labtop );
01798 
01799 // Deletes and releases memory used by a stripchart.
01800 
01801 PLDLLIMPEXP void
01802 c_plstripd( PLINT id );
01803 
01804 // plots a 2d image (or a matrix too large for plshade() )
01805 
01806 PLDLLIMPEXP void
01807 c_plimagefr( const PLFLT **idata, PLINT nx, PLINT ny,
01808              PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax,
01809              PLFLT valuemin, PLFLT valuemax,
01810              void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01811              PLPointer pltr_data );
01812 
01813 //
01814 // Like plimagefr, but uses an evaluator function to access image data from
01815 // idatap.  getminmax is only used if zmin == zmax.
01816 //
01817 
01818 PLDLLIMPEXP void
01819 plfimagefr( PLF2OPS idataops, PLPointer idatap, PLINT nx, PLINT ny,
01820             PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax,
01821             PLFLT valuemin, PLFLT valuemax,
01822             void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01823             PLPointer pltr_data );
01824 
01825 // plots a 2d image (or a matrix too large for plshade() ) - colors
01826 // automatically scaled
01827 
01828 PLDLLIMPEXP void
01829 c_plimage( const PLFLT **idata, PLINT nx, PLINT ny,
01830            PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax,
01831            PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax );
01832 
01833 //
01834 // Like plimage, but uses an operator functions to access image data from
01835 // idatap.
01836 //
01837 
01838 PLDLLIMPEXP void
01839 plfimage( PLF2OPS idataops, PLPointer idatap, PLINT nx, PLINT ny,
01840           PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax,
01841           PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax );
01842 
01843 // Set up a new line style
01844 
01845 PLDLLIMPEXP void
01846 c_plstyl( PLINT nms, const PLINT *mark, const PLINT *space );
01847 
01848 // Plots the 3d surface representation of the function z[x][y].
01849 
01850 PLDLLIMPEXP void
01851 c_plsurf3d( const PLFLT *x, const PLFLT *y, const PLFLT **z, PLINT nx, PLINT ny,
01852             PLINT opt, const PLFLT *clevel, PLINT nlevel );
01853 
01854 // Like plsurf3d, but uses an evaluator function to access z data from zp
01855 
01856 PLDLLIMPEXP void
01857 plfsurf3d( const PLFLT *x, const PLFLT *y, PLF2OPS zops, PLPointer zp,
01858            PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel );
01859 
01860 // Plots the 3d surface representation of the function z[x][y] with y
01861 // index limits.
01862 
01863 PLDLLIMPEXP void
01864 c_plsurf3dl( const PLFLT *x, const PLFLT *y, const PLFLT **z, PLINT nx, PLINT ny,
01865              PLINT opt, const PLFLT *clevel, PLINT nlevel,
01866              PLINT ixstart, PLINT ixn, const PLINT *indexymin, const PLINT *indexymax );
01867 
01868 // Like plsurf3dl, but uses an evaluator function to access z data from zp
01869 
01870 PLDLLIMPEXP void
01871 plfsurf3dl( const PLFLT *x, const PLFLT *y, PLF2OPS zops, PLPointer zp, PLINT nx, PLINT ny,
01872             PLINT opt, const PLFLT *clevel, PLINT nlevel,
01873             PLINT ixstart, PLINT ixn, const PLINT *indexymin, const PLINT * indexymax );
01874 
01875 PLDLLIMPEXP void
01876 c_plsvect( const PLFLT *arrowx, const PLFLT *arrowy, PLINT npts, PLBOOL fill );
01877 
01878 // Sets the edges of the viewport to the specified absolute coordinates
01879 
01880 PLDLLIMPEXP void
01881 c_plsvpa( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax );
01882 
01883 // Set x axis labeling parameters
01884 
01885 PLDLLIMPEXP void
01886 c_plsxax( PLINT digmax, PLINT digits );
01887 
01888 // Set inferior X window
01889 
01890 PLDLLIMPEXP void
01891 plsxwin( PLINT window_id );
01892 
01893 // Set y axis labeling parameters
01894 
01895 PLDLLIMPEXP void
01896 c_plsyax( PLINT digmax, PLINT digits );
01897 
01898 // Plots array y against x for n points using Hershey symbol "code"
01899 
01900 PLDLLIMPEXP void
01901 c_plsym( PLINT n, const PLFLT *x, const PLFLT *y, PLINT code );
01902 
01903 // Set z axis labeling parameters
01904 
01905 PLDLLIMPEXP void
01906 c_plszax( PLINT digmax, PLINT digits );
01907 
01908 // Switches to text screen.
01909 
01910 PLDLLIMPEXP void
01911 c_pltext( void );
01912 
01913 // Set the format for date / time labels for current stream.
01914 
01915 PLDLLIMPEXP void
01916 c_pltimefmt( const char *fmt );
01917 
01918 // Sets the edges of the viewport with the given aspect ratio, leaving
01919 // room for labels.
01920 
01921 PLDLLIMPEXP void
01922 c_plvasp( PLFLT aspect );
01923 
01924 // Creates the largest viewport of the specified aspect ratio that fits
01925 // within the specified normalized subpage coordinates.
01926 
01927 // simple arrow plotter.
01928 
01929 PLDLLIMPEXP void
01930 c_plvect( const PLFLT **u, const PLFLT **v, PLINT nx, PLINT ny, PLFLT scale,
01931           void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01932           PLPointer pltr_data );
01933 
01934 //
01935 // Routine to plot a vector array with arbitrary coordinate
01936 // and vector transformations
01937 //
01938 PLDLLIMPEXP void
01939 plfvect( PLFLT ( *getuv )( PLINT, PLINT, PLPointer ),
01940          PLPointer up, PLPointer vp,
01941          PLINT nx, PLINT ny, PLFLT scale,
01942          void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01943          PLPointer pltr_data );
01944 
01945 PLDLLIMPEXP void
01946 c_plvpas( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT aspect );
01947 
01948 // Creates a viewport with the specified normalized subpage coordinates.
01949 
01950 PLDLLIMPEXP void
01951 c_plvpor( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax );
01952 
01953 // Defines a "standard" viewport with seven character heights for
01954 // the left margin and four character heights everywhere else.
01955 
01956 PLDLLIMPEXP void
01957 c_plvsta( void );
01958 
01959 // Set up a window for three-dimensional plotting.
01960 
01961 PLDLLIMPEXP void
01962 c_plw3d( PLFLT basex, PLFLT basey, PLFLT height, PLFLT xmin0,
01963          PLFLT xmax0, PLFLT ymin0, PLFLT ymax0, PLFLT zmin0,
01964          PLFLT zmax0, PLFLT alt, PLFLT az );
01965 
01966 // Set pen width.
01967 
01968 PLDLLIMPEXP void
01969 c_plwid( PLINT width );
01970 
01971 // Set up world coordinates of the viewport boundaries (2d plots).
01972 
01973 PLDLLIMPEXP void
01974 c_plwind( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax );
01975 
01976 // Set xor mode; mode = 1-enter, 0-leave, status = 0 if not interactive device
01977 
01978 PLDLLIMPEXP void
01979 c_plxormod( PLBOOL mode, PLBOOL *status );
01980 
01981 
01982 //--------------------------------------------------------------------------
01983 //              Functions for use from C or C++ only
01984 //--------------------------------------------------------------------------
01985 
01986 // Returns a list of file-oriented device names and their menu strings
01987 
01988 PLDLLIMPEXP void
01989 plgFileDevs( const char ***p_menustr, const char ***p_devname, int *p_ndev );
01990 
01991 // Returns a list of all device names and their menu strings
01992 
01993 PLDLLIMPEXP void
01994 plgDevs( const char ***p_menustr, const char ***p_devname, int *p_ndev );
01995 
01996 // Set the function pointer for the keyboard event handler
01997 
01998 PLDLLIMPEXP void
01999 plsKeyEH( void ( *KeyEH )( PLGraphicsIn *, void *, int * ), void *KeyEH_data );
02000 
02001 // Set the function pointer for the (mouse) button event handler
02002 
02003 PLDLLIMPEXP void
02004 plsButtonEH( void ( *ButtonEH )( PLGraphicsIn *, void *, int * ),
02005              void *ButtonEH_data );
02006 
02007 // Sets an optional user bop handler
02008 
02009 PLDLLIMPEXP void
02010 plsbopH( void ( *handler )( void *, int * ), void *handler_data );
02011 
02012 // Sets an optional user eop handler
02013 
02014 PLDLLIMPEXP void
02015 plseopH( void ( *handler )( void *, int * ), void *handler_data );
02016 
02017 // Set the variables to be used for storing error info
02018 
02019 PLDLLIMPEXP void
02020 plsError( PLINT *errcode, char *errmsg );
02021 
02022 // Sets an optional user exit handler.
02023 
02024 PLDLLIMPEXP void
02025 plsexit( int ( *handler )( const char * ) );
02026 
02027 // Sets an optional user abort handler.
02028 
02029 PLDLLIMPEXP void
02030 plsabort( void ( *handler )( const char * ) );
02031 
02032 // Transformation routines
02033 
02034 // Identity transformation.
02035 
02036 PLDLLIMPEXP void
02037 pltr0( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data );
02038 
02039 // Does linear interpolation from singly dimensioned coord arrays.
02040 
02041 PLDLLIMPEXP void
02042 pltr1( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data );
02043 
02044 // Does linear interpolation from doubly dimensioned coord arrays
02045 // (column dominant, as per normal C 2d arrays).
02046 
02047 PLDLLIMPEXP void
02048 pltr2( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data );
02049 
02050 // Just like pltr2() but uses pointer arithmetic to get coordinates from
02051 // 2d grid tables.
02052 
02053 PLDLLIMPEXP void
02054 pltr2p( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data );
02055 
02056 // Does linear interpolation from doubly dimensioned coord arrays
02057 // (row dominant, i.e. Fortran ordering).
02058 
02059 PLDLLIMPEXP void
02060 pltr2f( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data );
02061 
02062 //
02063 // Returns a pointer to a plf2ops_t stucture with pointers to functions for
02064 // accessing 2-D data referenced as (PLFLT **), such as the C variable z
02065 // declared as...
02066 //
02067 //   PLFLT z[nx][ny];
02068 //
02069 
02070 PLDLLIMPEXP PLF2OPS
02071 plf2ops_c();
02072 
02073 //
02074 // Returns a pointer to a plf2ops_t stucture with pointers to functions for accessing 2-D data
02075 // referenced as (PLfGrid2 *), where the PLfGrid2's "f" is treated as type
02076 // (PLFLT **).
02077 //
02078 
02079 PLDLLIMPEXP PLF2OPS
02080 plf2ops_grid_c();
02081 
02082 //
02083 // Returns a pointer to a plf2ops_t stucture with pointers to functions for
02084 // accessing 2-D data stored in (PLfGrid2 *), with the PLfGrid2's "f" field
02085 // treated as type (PLFLT *) pointing to 2-D data stored in row-major order.
02086 // In the context of plotting, it might be easier to think of it as "X-major"
02087 // order.  In this ordering, values for a single X index are stored in
02088 // consecutive memory locations.
02089 //
02090 
02091 PLDLLIMPEXP PLF2OPS
02092 plf2ops_grid_row_major();
02093 
02094 //
02095 // Returns a pointer to a plf2ops_t stucture with pointers to functions for
02096 // accessing 2-D data stored in (PLfGrid2 *), with the PLfGrid2's "f" field
02097 // treated as type (PLFLT *) pointing to 2-D data stored in column-major order.
02098 // In the context of plotting, it might be easier to think of it as "Y-major"
02099 // order.  In this ordering, values for a single Y index are stored in
02100 // consecutive memory locations.
02101 //
02102 
02103 PLDLLIMPEXP PLF2OPS
02104 plf2ops_grid_col_major();
02105 
02106 
02107 // Function evaluators (Should these be deprecated in favor of plf2ops?)
02108 
02109 //
02110 // Does a lookup from a 2d function array.  plf2eval_data is treated as type
02111 // (PLFLT **) and data for (ix,iy) is returned from...
02112 //
02113 // plf2eval_data[ix][iy];
02114 //
02115 
02116 PLDLLIMPEXP PLFLT
02117 plf2eval1( PLINT ix, PLINT iy, PLPointer plf2eval_data );
02118 
02119 //
02120 // Does a lookup from a 2d function array.  plf2eval_data is treated as type
02121 // (PLfGrid2 *) and data for (ix,iy) is returned from...
02122 //
02123 // plf2eval_data->f[ix][iy];
02124 //
02125 
02126 PLDLLIMPEXP PLFLT
02127 plf2eval2( PLINT ix, PLINT iy, PLPointer plf2eval_data );
02128 
02129 //
02130 // Does a lookup from a 2d function array.  plf2eval_data is treated as type
02131 // (PLfGrid *) and data for (ix,iy) is returned from...
02132 //
02133 // plf2eval_data->f[ix * plf2eval_data->ny + iy];
02134 //
02135 // This is commonly called "row-major order", but in the context of plotting,
02136 // it might be easier to think of it as "X-major order".  In this ordering,
02137 // values for a single X index are stored in consecutive memory locations.
02138 // This is also known as C ordering.
02139 //
02140 
02141 PLDLLIMPEXP PLFLT
02142 plf2eval( PLINT ix, PLINT iy, PLPointer plf2eval_data );
02143 
02144 //
02145 // Does a lookup from a 2d function array.  plf2eval_data is treated as type
02146 // (PLfGrid *) and data for (ix,iy) is returned from...
02147 //
02148 // plf2eval_data->f[ix + iy * plf2eval_data->nx];
02149 //
02150 // This is commonly called "column-major order", but in the context of
02151 // plotting, it might be easier to think of it as "Y-major order".  In this
02152 // ordering, values for a single Y index are stored in consecutive memory
02153 // locations.  This is also known as FORTRAN ordering.
02154 //
02155 
02156 PLDLLIMPEXP PLFLT
02157 plf2evalr( PLINT ix, PLINT iy, PLPointer plf2eval_data );
02158 
02159 // Command line parsing utilities
02160 
02161 // Clear internal option table info structure.
02162 
02163 PLDLLIMPEXP void
02164 plClearOpts( void );
02165 
02166 // Reset internal option table info structure.
02167 
02168 PLDLLIMPEXP void
02169 plResetOpts( void );
02170 
02171 // Merge user option table into internal info structure.
02172 
02173 PLDLLIMPEXP int
02174 plMergeOpts( PLOptionTable *options, const char *name, const char **notes );
02175 
02176 // Set the strings used in usage and syntax messages.
02177 
02178 PLDLLIMPEXP void
02179 plSetUsage( const char *program_string, const char *usage_string );
02180 
02181 // Process input strings, treating them as an option and argument pair.
02182 // The first is for the external API, the second the work routine declared
02183 // here for backward compatibilty.
02184 
02185 PLDLLIMPEXP int
02186 c_plsetopt( const char *opt, const char *optarg );
02187 
02188 #ifdef PL_DEPRECATED
02189 
02190 PLDLLIMPEXP int
02191 plSetOpt( const char *opt, const char *optarg );
02192 
02193 #endif // PL_DEPRECATED
02194 
02195 // Process options list using current options info.
02196 
02197 PLDLLIMPEXP int
02198 c_plparseopts( int *p_argc, const char **argv, PLINT mode );
02199 
02200 // Print usage & syntax message.
02201 
02202 PLDLLIMPEXP void
02203 plOptUsage( void );
02204 
02205 // Miscellaneous
02206 
02207 // Set the output file pointer
02208 
02209 PLDLLIMPEXP void
02210 plgfile( FILE **p_file );
02211 
02212 // Get the output file pointer
02213 
02214 PLDLLIMPEXP void
02215 plsfile( FILE *file );
02216 
02217 // Get the escape character for text strings.
02218 
02219 PLDLLIMPEXP void
02220 plgesc( char *p_esc );
02221 
02222 // Front-end to driver escape function.
02223 
02224 PLDLLIMPEXP void
02225 pl_cmd( PLINT op, void *ptr );
02226 
02227 // Return full pathname for given file if executable
02228 
02229 PLDLLIMPEXP int
02230 plFindName( char *p );
02231 
02232 // Looks for the specified executable file according to usual search path.
02233 
02234 PLDLLIMPEXP char *
02235 plFindCommand( const char *fn );
02236 
02237 // Gets search name for file by concatenating the dir, subdir, and file
02238 // name, allocating memory as needed.
02239 
02240 PLDLLIMPEXP void
02241 plGetName( const char *dir, const char *subdir, const char *filename, char **filespec );
02242 
02243 // Prompts human to input an integer in response to given message.
02244 
02245 PLDLLIMPEXP PLINT
02246 plGetInt( const char *s );
02247 
02248 // Prompts human to input a float in response to given message.
02249 
02250 PLDLLIMPEXP PLFLT
02251 plGetFlt( const char *s );
02252 
02253 // Nice way to allocate space for a vectored 2d grid
02254 
02255 // Allocates a block of memory for use as a 2-d grid of PLFLT's.
02256 
02257 PLDLLIMPEXP void
02258 plAlloc2dGrid( PLFLT ***f, PLINT nx, PLINT ny );
02259 
02260 // Frees a block of memory allocated with plAlloc2dGrid().
02261 
02262 PLDLLIMPEXP void
02263 plFree2dGrid( PLFLT **f, PLINT nx, PLINT ny );
02264 
02265 // Find the maximum and minimum of a 2d matrix allocated with plAllc2dGrid().
02266 
02267 PLDLLIMPEXP void
02268 plMinMax2dGrid( const PLFLT **f, PLINT nx, PLINT ny, PLFLT *fmax, PLFLT *fmin );
02269 
02270 // Wait for graphics input event and translate to world coordinates
02271 
02272 PLDLLIMPEXP int
02273 plGetCursor( PLGraphicsIn *gin );
02274 
02275 // Translates relative device coordinates to world coordinates.
02276 
02277 PLDLLIMPEXP int
02278 plTranslateCursor( PLGraphicsIn *gin );
02279 
02280 #ifdef PL_DEPRECATED
02281 
02282 // These functions are depreciated and only retained for backwards
02283 // compatibility - do not use in new code.
02284 
02285 // Set current color (map 0) by hue, lightness, and saturation.
02286 
02287 PLDLLIMPEXP void
02288 c_plhls( PLFLT h, PLFLT l, PLFLT s );
02289 
02290 // Set line color by red, green, blue from  0. to 1.
02291 
02292 PLDLLIMPEXP void
02293 c_plrgb( PLFLT r, PLFLT g, PLFLT b );
02294 
02295 // Set line color by 8 bit RGB values.
02296 
02297 PLDLLIMPEXP void
02298 c_plrgb1( PLINT r, PLINT g, PLINT b );
02299 
02300 #endif // PL_DEPRECATED
02301 
02302 
02303 #ifdef __cplusplus
02304 }
02305 #endif
02306 #if 0
02307 #if defined ( __GNUC__ ) && __GNUC__ > 3
02308   #pragma GCC visibility pop
02309 #endif
02310 #endif
02311 
02312 #endif  // __PLPLOT_H__

Generated on Wed Oct 12 2011 20:42:22 for PLplot by  doxygen 1.7.1