PLplot  5.10.0
plplotcmodulePYTHON_wrap.c
Go to the documentation of this file.
00001 /* ----------------------------------------------------------------------------
00002  * This file was automatically generated by SWIG (http://www.swig.org).
00003  * Version 3.0.2
00004  *
00005  * This file is not intended to be easily readable and contains a number of
00006  * coding conventions designed to improve portability and efficiency. Do not make
00007  * changes to this file unless you know what you are doing--modify the SWIG
00008  * interface file instead.
00009  * ----------------------------------------------------------------------------- */
00010 
00011 #define SWIGPYTHON
00012 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
00013 
00014 /* -----------------------------------------------------------------------------
00015  *  This section contains generic SWIG labels for method/variable
00016  *  declarations/attributes, and other compiler dependent labels.
00017  * ----------------------------------------------------------------------------- */
00018 
00019 /* template workaround for compilers that cannot correctly implement the C++ standard */
00020 #ifndef SWIGTEMPLATEDISAMBIGUATOR
00021 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
00022 #  define SWIGTEMPLATEDISAMBIGUATOR template
00023 # elif defined(__HP_aCC)
00024 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
00025 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
00026 #  define SWIGTEMPLATEDISAMBIGUATOR template
00027 # else
00028 #  define SWIGTEMPLATEDISAMBIGUATOR
00029 # endif
00030 #endif
00031 
00032 /* inline attribute */
00033 #ifndef SWIGINLINE
00034 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
00035 #   define SWIGINLINE inline
00036 # else
00037 #   define SWIGINLINE
00038 # endif
00039 #endif
00040 
00041 /* attribute recognised by some compilers to avoid 'unused' warnings */
00042 #ifndef SWIGUNUSED
00043 # if defined(__GNUC__)
00044 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
00045 #     define SWIGUNUSED __attribute__ ((__unused__))
00046 #   else
00047 #     define SWIGUNUSED
00048 #   endif
00049 # elif defined(__ICC)
00050 #   define SWIGUNUSED __attribute__ ((__unused__))
00051 # else
00052 #   define SWIGUNUSED
00053 # endif
00054 #endif
00055 
00056 #ifndef SWIG_MSC_UNSUPPRESS_4505
00057 # if defined(_MSC_VER)
00058 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
00059 # endif
00060 #endif
00061 
00062 #ifndef SWIGUNUSEDPARM
00063 # ifdef __cplusplus
00064 #   define SWIGUNUSEDPARM(p)
00065 # else
00066 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
00067 # endif
00068 #endif
00069 
00070 /* internal SWIG method */
00071 #ifndef SWIGINTERN
00072 # define SWIGINTERN static SWIGUNUSED
00073 #endif
00074 
00075 /* internal inline SWIG method */
00076 #ifndef SWIGINTERNINLINE
00077 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
00078 #endif
00079 
00080 /* exporting methods */
00081 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
00082 #  ifndef GCC_HASCLASSVISIBILITY
00083 #    define GCC_HASCLASSVISIBILITY
00084 #  endif
00085 #endif
00086 
00087 #ifndef SWIGEXPORT
00088 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
00089 #   if defined(STATIC_LINKED)
00090 #     define SWIGEXPORT
00091 #   else
00092 #     define SWIGEXPORT __declspec(dllexport)
00093 #   endif
00094 # else
00095 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
00096 #     define SWIGEXPORT __attribute__ ((visibility("default")))
00097 #   else
00098 #     define SWIGEXPORT
00099 #   endif
00100 # endif
00101 #endif
00102 
00103 /* calling conventions for Windows */
00104 #ifndef SWIGSTDCALL
00105 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
00106 #   define SWIGSTDCALL __stdcall
00107 # else
00108 #   define SWIGSTDCALL
00109 # endif
00110 #endif
00111 
00112 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
00113 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
00114 # define _CRT_SECURE_NO_DEPRECATE
00115 #endif
00116 
00117 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
00118 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
00119 # define _SCL_SECURE_NO_DEPRECATE
00120 #endif
00121 
00122 
00123 
00124 #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
00125 /* Use debug wrappers with the Python release dll */
00126 # undef _DEBUG
00127 # include <Python.h>
00128 # define _DEBUG
00129 #else
00130 # include <Python.h>
00131 #endif
00132 
00133 /* -----------------------------------------------------------------------------
00134  * swigrun.swg
00135  *
00136  * This file contains generic C API SWIG runtime support for pointer
00137  * type checking.
00138  * ----------------------------------------------------------------------------- */
00139 
00140 /* This should only be incremented when either the layout of swig_type_info changes,
00141    or for whatever reason, the runtime changes incompatibly */
00142 #define SWIG_RUNTIME_VERSION "4"
00143 
00144 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
00145 #ifdef SWIG_TYPE_TABLE
00146 # define SWIG_QUOTE_STRING(x) #x
00147 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
00148 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
00149 #else
00150 # define SWIG_TYPE_TABLE_NAME
00151 #endif
00152 
00153 /*
00154   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
00155   creating a static or dynamic library from the SWIG runtime code.
00156   In 99.9% of the cases, SWIG just needs to declare them as 'static'.
00157 
00158   But only do this if strictly necessary, ie, if you have problems
00159   with your compiler or suchlike.
00160 */
00161 
00162 #ifndef SWIGRUNTIME
00163 # define SWIGRUNTIME SWIGINTERN
00164 #endif
00165 
00166 #ifndef SWIGRUNTIMEINLINE
00167 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
00168 #endif
00169 
00170 /*  Generic buffer size */
00171 #ifndef SWIG_BUFFER_SIZE
00172 # define SWIG_BUFFER_SIZE 1024
00173 #endif
00174 
00175 /* Flags for pointer conversions */
00176 #define SWIG_POINTER_DISOWN        0x1
00177 #define SWIG_CAST_NEW_MEMORY       0x2
00178 
00179 /* Flags for new pointer objects */
00180 #define SWIG_POINTER_OWN           0x1
00181 
00182 
00183 /*
00184    Flags/methods for returning states.
00185 
00186    The SWIG conversion methods, as ConvertPtr, return an integer
00187    that tells if the conversion was successful or not. And if not,
00188    an error code can be returned (see swigerrors.swg for the codes).
00189 
00190    Use the following macros/flags to set or process the returning
00191    states.
00192 
00193    In old versions of SWIG, code such as the following was usually written:
00194 
00195      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
00196        // success code
00197      } else {
00198        //fail code
00199      }
00200 
00201    Now you can be more explicit:
00202 
00203     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
00204     if (SWIG_IsOK(res)) {
00205       // success code
00206     } else {
00207       // fail code
00208     }
00209 
00210    which is the same really, but now you can also do
00211 
00212     Type *ptr;
00213     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
00214     if (SWIG_IsOK(res)) {
00215       // success code
00216       if (SWIG_IsNewObj(res) {
00217         ...
00218         delete *ptr;
00219       } else {
00220         ...
00221       }
00222     } else {
00223       // fail code
00224     }
00225 
00226    I.e., now SWIG_ConvertPtr can return new objects and you can
00227    identify the case and take care of the deallocation. Of course that
00228    also requires SWIG_ConvertPtr to return new result values, such as
00229 
00230       int SWIG_ConvertPtr(obj, ptr,...) {
00231         if (<obj is ok>) {
00232           if (<need new object>) {
00233             *ptr = <ptr to new allocated object>;
00234             return SWIG_NEWOBJ;
00235           } else {
00236             *ptr = <ptr to old object>;
00237             return SWIG_OLDOBJ;
00238           }
00239         } else {
00240           return SWIG_BADOBJ;
00241         }
00242       }
00243 
00244    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
00245    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
00246    SWIG errors code.
00247 
00248    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
00249    allows to return the 'cast rank', for example, if you have this
00250 
00251        int food(double)
00252        int fooi(int);
00253 
00254    and you call
00255 
00256       food(1)   // cast rank '1'  (1 -> 1.0)
00257       fooi(1)   // cast rank '0'
00258 
00259    just use the SWIG_AddCast()/SWIG_CheckState()
00260 */
00261 
00262 #define SWIG_OK                    (0)
00263 #define SWIG_ERROR                 (-1)
00264 #define SWIG_IsOK(r)               (r >= 0)
00265 #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
00266 
00267 /* The CastRankLimit says how many bits are used for the cast rank */
00268 #define SWIG_CASTRANKLIMIT         (1 << 8)
00269 /* The NewMask denotes the object was created (using new/malloc) */
00270 #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
00271 /* The TmpMask is for in/out typemaps that use temporal objects */
00272 #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
00273 /* Simple returning values */
00274 #define SWIG_BADOBJ                (SWIG_ERROR)
00275 #define SWIG_OLDOBJ                (SWIG_OK)
00276 #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
00277 #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
00278 /* Check, add and del mask methods */
00279 #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
00280 #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
00281 #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
00282 #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
00283 #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
00284 #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
00285 
00286 /* Cast-Rank Mode */
00287 #if defined(SWIG_CASTRANK_MODE)
00288 #  ifndef SWIG_TypeRank
00289 #    define SWIG_TypeRank             unsigned long
00290 #  endif
00291 #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
00292 #    define SWIG_MAXCASTRANK          (2)
00293 #  endif
00294 #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
00295 #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
00296 SWIGINTERNINLINE int SWIG_AddCast(int r) {
00297   return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
00298 }
00299 SWIGINTERNINLINE int SWIG_CheckState(int r) {
00300   return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
00301 }
00302 #else /* no cast-rank mode */
00303 #  define SWIG_AddCast(r) (r)
00304 #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
00305 #endif
00306 
00307 
00308 #include <string.h>
00309 
00310 #ifdef __cplusplus
00311 extern "C" {
00312 #endif
00313 
00314 typedef void *(*swig_converter_func)(void *, int *);
00315 typedef struct swig_type_info *(*swig_dycast_func)(void **);
00316 
00317 /* Structure to store information on one type */
00318 typedef struct swig_type_info {
00319   const char             *name;                 /* mangled name of this type */
00320   const char             *str;                  /* human readable name of this type */
00321   swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
00322   struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
00323   void                   *clientdata;           /* language specific type data */
00324   int                    owndata;               /* flag if the structure owns the clientdata */
00325 } swig_type_info;
00326 
00327 /* Structure to store a type and conversion function used for casting */
00328 typedef struct swig_cast_info {
00329   swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
00330   swig_converter_func     converter;            /* function to cast the void pointers */
00331   struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
00332   struct swig_cast_info  *prev;                 /* pointer to the previous cast */
00333 } swig_cast_info;
00334 
00335 /* Structure used to store module information
00336  * Each module generates one structure like this, and the runtime collects
00337  * all of these structures and stores them in a circularly linked list.*/
00338 typedef struct swig_module_info {
00339   swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
00340   size_t                 size;                  /* Number of types in this module */
00341   struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
00342   swig_type_info         **type_initial;        /* Array of initially generated type structures */
00343   swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
00344   void                    *clientdata;          /* Language specific module data */
00345 } swig_module_info;
00346 
00347 /*
00348   Compare two type names skipping the space characters, therefore
00349   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
00350 
00351   Return 0 when the two name types are equivalent, as in
00352   strncmp, but skipping ' '.
00353 */
00354 SWIGRUNTIME int
00355 SWIG_TypeNameComp(const char *f1, const char *l1,
00356                   const char *f2, const char *l2) {
00357   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
00358     while ((*f1 == ' ') && (f1 != l1)) ++f1;
00359     while ((*f2 == ' ') && (f2 != l2)) ++f2;
00360     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
00361   }
00362   return (int)((l1 - f1) - (l2 - f2));
00363 }
00364 
00365 /*
00366   Check type equivalence in a name list like <name1>|<name2>|...
00367   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
00368 */
00369 SWIGRUNTIME int
00370 SWIG_TypeCmp(const char *nb, const char *tb) {
00371   int equiv = 1;
00372   const char* te = tb + strlen(tb);
00373   const char* ne = nb;
00374   while (equiv != 0 && *ne) {
00375     for (nb = ne; *ne; ++ne) {
00376       if (*ne == '|') break;
00377     }
00378     equiv = SWIG_TypeNameComp(nb, ne, tb, te);
00379     if (*ne) ++ne;
00380   }
00381   return equiv;
00382 }
00383 
00384 /*
00385   Check type equivalence in a name list like <name1>|<name2>|...
00386   Return 0 if not equal, 1 if equal
00387 */
00388 SWIGRUNTIME int
00389 SWIG_TypeEquiv(const char *nb, const char *tb) {
00390   return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
00391 }
00392 
00393 /*
00394   Check the typename
00395 */
00396 SWIGRUNTIME swig_cast_info *
00397 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
00398   if (ty) {
00399     swig_cast_info *iter = ty->cast;
00400     while (iter) {
00401       if (strcmp(iter->type->name, c) == 0) {
00402         if (iter == ty->cast)
00403           return iter;
00404         /* Move iter to the top of the linked list */
00405         iter->prev->next = iter->next;
00406         if (iter->next)
00407           iter->next->prev = iter->prev;
00408         iter->next = ty->cast;
00409         iter->prev = 0;
00410         if (ty->cast) ty->cast->prev = iter;
00411         ty->cast = iter;
00412         return iter;
00413       }
00414       iter = iter->next;
00415     }
00416   }
00417   return 0;
00418 }
00419 
00420 /*
00421   Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
00422 */
00423 SWIGRUNTIME swig_cast_info *
00424 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
00425   if (ty) {
00426     swig_cast_info *iter = ty->cast;
00427     while (iter) {
00428       if (iter->type == from) {
00429         if (iter == ty->cast)
00430           return iter;
00431         /* Move iter to the top of the linked list */
00432         iter->prev->next = iter->next;
00433         if (iter->next)
00434           iter->next->prev = iter->prev;
00435         iter->next = ty->cast;
00436         iter->prev = 0;
00437         if (ty->cast) ty->cast->prev = iter;
00438         ty->cast = iter;
00439         return iter;
00440       }
00441       iter = iter->next;
00442     }
00443   }
00444   return 0;
00445 }
00446 
00447 /*
00448   Cast a pointer up an inheritance hierarchy
00449 */
00450 SWIGRUNTIMEINLINE void *
00451 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
00452   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
00453 }
00454 
00455 /*
00456    Dynamic pointer casting. Down an inheritance hierarchy
00457 */
00458 SWIGRUNTIME swig_type_info *
00459 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
00460   swig_type_info *lastty = ty;
00461   if (!ty || !ty->dcast) return ty;
00462   while (ty && (ty->dcast)) {
00463     ty = (*ty->dcast)(ptr);
00464     if (ty) lastty = ty;
00465   }
00466   return lastty;
00467 }
00468 
00469 /*
00470   Return the name associated with this type
00471 */
00472 SWIGRUNTIMEINLINE const char *
00473 SWIG_TypeName(const swig_type_info *ty) {
00474   return ty->name;
00475 }
00476 
00477 /*
00478   Return the pretty name associated with this type,
00479   that is an unmangled type name in a form presentable to the user.
00480 */
00481 SWIGRUNTIME const char *
00482 SWIG_TypePrettyName(const swig_type_info *type) {
00483   /* The "str" field contains the equivalent pretty names of the
00484      type, separated by vertical-bar characters.  We choose
00485      to print the last name, as it is often (?) the most
00486      specific. */
00487   if (!type) return NULL;
00488   if (type->str != NULL) {
00489     const char *last_name = type->str;
00490     const char *s;
00491     for (s = type->str; *s; s++)
00492       if (*s == '|') last_name = s+1;
00493     return last_name;
00494   }
00495   else
00496     return type->name;
00497 }
00498 
00499 /*
00500    Set the clientdata field for a type
00501 */
00502 SWIGRUNTIME void
00503 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
00504   swig_cast_info *cast = ti->cast;
00505   /* if (ti->clientdata == clientdata) return; */
00506   ti->clientdata = clientdata;
00507 
00508   while (cast) {
00509     if (!cast->converter) {
00510       swig_type_info *tc = cast->type;
00511       if (!tc->clientdata) {
00512         SWIG_TypeClientData(tc, clientdata);
00513       }
00514     }
00515     cast = cast->next;
00516   }
00517 }
00518 SWIGRUNTIME void
00519 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
00520   SWIG_TypeClientData(ti, clientdata);
00521   ti->owndata = 1;
00522 }
00523 
00524 /*
00525   Search for a swig_type_info structure only by mangled name
00526   Search is a O(log #types)
00527 
00528   We start searching at module start, and finish searching when start == end.
00529   Note: if start == end at the beginning of the function, we go all the way around
00530   the circular list.
00531 */
00532 SWIGRUNTIME swig_type_info *
00533 SWIG_MangledTypeQueryModule(swig_module_info *start,
00534                             swig_module_info *end,
00535                             const char *name) {
00536   swig_module_info *iter = start;
00537   do {
00538     if (iter->size) {
00539       size_t l = 0;
00540       size_t r = iter->size - 1;
00541       do {
00542         /* since l+r >= 0, we can (>> 1) instead (/ 2) */
00543         size_t i = (l + r) >> 1;
00544         const char *iname = iter->types[i]->name;
00545         if (iname) {
00546           int compare = strcmp(name, iname);
00547           if (compare == 0) {
00548             return iter->types[i];
00549           } else if (compare < 0) {
00550             if (i) {
00551               r = i - 1;
00552             } else {
00553               break;
00554             }
00555           } else if (compare > 0) {
00556             l = i + 1;
00557           }
00558         } else {
00559           break; /* should never happen */
00560         }
00561       } while (l <= r);
00562     }
00563     iter = iter->next;
00564   } while (iter != end);
00565   return 0;
00566 }
00567 
00568 /*
00569   Search for a swig_type_info structure for either a mangled name or a human readable name.
00570   It first searches the mangled names of the types, which is a O(log #types)
00571   If a type is not found it then searches the human readable names, which is O(#types).
00572 
00573   We start searching at module start, and finish searching when start == end.
00574   Note: if start == end at the beginning of the function, we go all the way around
00575   the circular list.
00576 */
00577 SWIGRUNTIME swig_type_info *
00578 SWIG_TypeQueryModule(swig_module_info *start,
00579                      swig_module_info *end,
00580                      const char *name) {
00581   /* STEP 1: Search the name field using binary search */
00582   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
00583   if (ret) {
00584     return ret;
00585   } else {
00586     /* STEP 2: If the type hasn't been found, do a complete search
00587        of the str field (the human readable name) */
00588     swig_module_info *iter = start;
00589     do {
00590       size_t i = 0;
00591       for (; i < iter->size; ++i) {
00592         if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
00593           return iter->types[i];
00594       }
00595       iter = iter->next;
00596     } while (iter != end);
00597   }
00598 
00599   /* neither found a match */
00600   return 0;
00601 }
00602 
00603 /*
00604    Pack binary data into a string
00605 */
00606 SWIGRUNTIME char *
00607 SWIG_PackData(char *c, void *ptr, size_t sz) {
00608   static const char hex[17] = "0123456789abcdef";
00609   const unsigned char *u = (unsigned char *) ptr;
00610   const unsigned char *eu =  u + sz;
00611   for (; u != eu; ++u) {
00612     unsigned char uu = *u;
00613     *(c++) = hex[(uu & 0xf0) >> 4];
00614     *(c++) = hex[uu & 0xf];
00615   }
00616   return c;
00617 }
00618 
00619 /*
00620    Unpack binary data from a string
00621 */
00622 SWIGRUNTIME const char *
00623 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
00624   unsigned char *u = (unsigned char *) ptr;
00625   const unsigned char *eu = u + sz;
00626   for (; u != eu; ++u) {
00627     char d = *(c++);
00628     unsigned char uu;
00629     if ((d >= '0') && (d <= '9'))
00630       uu = ((d - '0') << 4);
00631     else if ((d >= 'a') && (d <= 'f'))
00632       uu = ((d - ('a'-10)) << 4);
00633     else
00634       return (char *) 0;
00635     d = *(c++);
00636     if ((d >= '0') && (d <= '9'))
00637       uu |= (d - '0');
00638     else if ((d >= 'a') && (d <= 'f'))
00639       uu |= (d - ('a'-10));
00640     else
00641       return (char *) 0;
00642     *u = uu;
00643   }
00644   return c;
00645 }
00646 
00647 /*
00648    Pack 'void *' into a string buffer.
00649 */
00650 SWIGRUNTIME char *
00651 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
00652   char *r = buff;
00653   if ((2*sizeof(void *) + 2) > bsz) return 0;
00654   *(r++) = '_';
00655   r = SWIG_PackData(r,&ptr,sizeof(void *));
00656   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
00657   strcpy(r,name);
00658   return buff;
00659 }
00660 
00661 SWIGRUNTIME const char *
00662 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
00663   if (*c != '_') {
00664     if (strcmp(c,"NULL") == 0) {
00665       *ptr = (void *) 0;
00666       return name;
00667     } else {
00668       return 0;
00669     }
00670   }
00671   return SWIG_UnpackData(++c,ptr,sizeof(void *));
00672 }
00673 
00674 SWIGRUNTIME char *
00675 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
00676   char *r = buff;
00677   size_t lname = (name ? strlen(name) : 0);
00678   if ((2*sz + 2 + lname) > bsz) return 0;
00679   *(r++) = '_';
00680   r = SWIG_PackData(r,ptr,sz);
00681   if (lname) {
00682     strncpy(r,name,lname+1);
00683   } else {
00684     *r = 0;
00685   }
00686   return buff;
00687 }
00688 
00689 SWIGRUNTIME const char *
00690 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
00691   if (*c != '_') {
00692     if (strcmp(c,"NULL") == 0) {
00693       memset(ptr,0,sz);
00694       return name;
00695     } else {
00696       return 0;
00697     }
00698   }
00699   return SWIG_UnpackData(++c,ptr,sz);
00700 }
00701 
00702 #ifdef __cplusplus
00703 }
00704 #endif
00705 
00706 /*  Errors in SWIG */
00707 #define  SWIG_UnknownError         -1
00708 #define  SWIG_IOError              -2
00709 #define  SWIG_RuntimeError         -3
00710 #define  SWIG_IndexError           -4
00711 #define  SWIG_TypeError            -5
00712 #define  SWIG_DivisionByZero       -6
00713 #define  SWIG_OverflowError        -7
00714 #define  SWIG_SyntaxError          -8
00715 #define  SWIG_ValueError           -9
00716 #define  SWIG_SystemError          -10
00717 #define  SWIG_AttributeError       -11
00718 #define  SWIG_MemoryError          -12
00719 #define  SWIG_NullReferenceError   -13
00720 
00721 
00722 
00723 /* Compatibility macros for Python 3 */
00724 #if PY_VERSION_HEX >= 0x03000000
00725 
00726 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
00727 #define PyInt_Check(x) PyLong_Check(x)
00728 #define PyInt_AsLong(x) PyLong_AsLong(x)
00729 #define PyInt_FromLong(x) PyLong_FromLong(x)
00730 #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
00731 #define PyString_Check(name) PyBytes_Check(name)
00732 #define PyString_FromString(x) PyUnicode_FromString(x)
00733 #define PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)
00734 #define PyString_AsString(str) PyBytes_AsString(str)
00735 #define PyString_Size(str) PyBytes_Size(str)    
00736 #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
00737 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
00738 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
00739 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
00740 
00741 #endif
00742 
00743 #ifndef Py_TYPE
00744 #  define Py_TYPE(op) ((op)->ob_type)
00745 #endif
00746 
00747 /* SWIG APIs for compatibility of both Python 2 & 3 */
00748 
00749 #if PY_VERSION_HEX >= 0x03000000
00750 #  define SWIG_Python_str_FromFormat PyUnicode_FromFormat
00751 #else
00752 #  define SWIG_Python_str_FromFormat PyString_FromFormat
00753 #endif
00754 
00755 
00756 /* Warning: This function will allocate a new string in Python 3,
00757  * so please call SWIG_Python_str_DelForPy3(x) to free the space.
00758  */
00759 SWIGINTERN char*
00760 SWIG_Python_str_AsChar(PyObject *str)
00761 {
00762 #if PY_VERSION_HEX >= 0x03000000
00763   char *cstr;
00764   char *newstr;
00765   Py_ssize_t len;
00766   str = PyUnicode_AsUTF8String(str);
00767   PyBytes_AsStringAndSize(str, &cstr, &len);
00768   newstr = (char *) malloc(len+1);
00769   memcpy(newstr, cstr, len+1);
00770   Py_XDECREF(str);
00771   return newstr;
00772 #else
00773   return PyString_AsString(str);
00774 #endif
00775 }
00776 
00777 #if PY_VERSION_HEX >= 0x03000000
00778 #  define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
00779 #else
00780 #  define SWIG_Python_str_DelForPy3(x) 
00781 #endif
00782 
00783 
00784 SWIGINTERN PyObject*
00785 SWIG_Python_str_FromChar(const char *c)
00786 {
00787 #if PY_VERSION_HEX >= 0x03000000
00788   return PyUnicode_FromString(c); 
00789 #else
00790   return PyString_FromString(c);
00791 #endif
00792 }
00793 
00794 /* Add PyOS_snprintf for old Pythons */
00795 #if PY_VERSION_HEX < 0x02020000
00796 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
00797 #  define PyOS_snprintf _snprintf
00798 # else
00799 #  define PyOS_snprintf snprintf
00800 # endif
00801 #endif
00802 
00803 /* A crude PyString_FromFormat implementation for old Pythons */
00804 #if PY_VERSION_HEX < 0x02020000
00805 
00806 #ifndef SWIG_PYBUFFER_SIZE
00807 # define SWIG_PYBUFFER_SIZE 1024
00808 #endif
00809 
00810 static PyObject *
00811 PyString_FromFormat(const char *fmt, ...) {
00812   va_list ap;
00813   char buf[SWIG_PYBUFFER_SIZE * 2];
00814   int res;
00815   va_start(ap, fmt);
00816   res = vsnprintf(buf, sizeof(buf), fmt, ap);
00817   va_end(ap);
00818   return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
00819 }
00820 #endif
00821 
00822 /* Add PyObject_Del for old Pythons */
00823 #if PY_VERSION_HEX < 0x01060000
00824 # define PyObject_Del(op) PyMem_DEL((op))
00825 #endif
00826 #ifndef PyObject_DEL
00827 # define PyObject_DEL PyObject_Del
00828 #endif
00829 
00830 /* A crude PyExc_StopIteration exception for old Pythons */
00831 #if PY_VERSION_HEX < 0x02020000
00832 # ifndef PyExc_StopIteration
00833 #  define PyExc_StopIteration PyExc_RuntimeError
00834 # endif
00835 # ifndef PyObject_GenericGetAttr
00836 #  define PyObject_GenericGetAttr 0
00837 # endif
00838 #endif
00839 
00840 /* Py_NotImplemented is defined in 2.1 and up. */
00841 #if PY_VERSION_HEX < 0x02010000
00842 # ifndef Py_NotImplemented
00843 #  define Py_NotImplemented PyExc_RuntimeError
00844 # endif
00845 #endif
00846 
00847 /* A crude PyString_AsStringAndSize implementation for old Pythons */
00848 #if PY_VERSION_HEX < 0x02010000
00849 # ifndef PyString_AsStringAndSize
00850 #  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
00851 # endif
00852 #endif
00853 
00854 /* PySequence_Size for old Pythons */
00855 #if PY_VERSION_HEX < 0x02000000
00856 # ifndef PySequence_Size
00857 #  define PySequence_Size PySequence_Length
00858 # endif
00859 #endif
00860 
00861 /* PyBool_FromLong for old Pythons */
00862 #if PY_VERSION_HEX < 0x02030000
00863 static
00864 PyObject *PyBool_FromLong(long ok)
00865 {
00866   PyObject *result = ok ? Py_True : Py_False;
00867   Py_INCREF(result);
00868   return result;
00869 }
00870 #endif
00871 
00872 /* Py_ssize_t for old Pythons */
00873 /* This code is as recommended by: */
00874 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
00875 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
00876 typedef int Py_ssize_t;
00877 # define PY_SSIZE_T_MAX INT_MAX
00878 # define PY_SSIZE_T_MIN INT_MIN
00879 typedef inquiry lenfunc;
00880 typedef intargfunc ssizeargfunc;
00881 typedef intintargfunc ssizessizeargfunc;
00882 typedef intobjargproc ssizeobjargproc;
00883 typedef intintobjargproc ssizessizeobjargproc;
00884 typedef getreadbufferproc readbufferproc;
00885 typedef getwritebufferproc writebufferproc;
00886 typedef getsegcountproc segcountproc;
00887 typedef getcharbufferproc charbufferproc;
00888 static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
00889 {
00890   long result = 0;
00891   PyObject *i = PyNumber_Int(x);
00892   if (i) {
00893     result = PyInt_AsLong(i);
00894     Py_DECREF(i);
00895   }
00896   return result;
00897 }
00898 #endif
00899 
00900 #if PY_VERSION_HEX < 0x02050000
00901 #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
00902 #endif
00903 
00904 #if PY_VERSION_HEX < 0x02040000
00905 #define Py_VISIT(op)                            \
00906   do {                                          \
00907     if (op) {                                   \
00908       int vret = visit((op), arg);              \
00909       if (vret)                                 \
00910         return vret;                            \
00911     }                                           \
00912   } while (0)
00913 #endif
00914 
00915 #if PY_VERSION_HEX < 0x02030000
00916 typedef struct {
00917   PyTypeObject type;
00918   PyNumberMethods as_number;
00919   PyMappingMethods as_mapping;
00920   PySequenceMethods as_sequence;
00921   PyBufferProcs as_buffer;
00922   PyObject *name, *slots;
00923 } PyHeapTypeObject;
00924 #endif
00925 
00926 #if PY_VERSION_HEX < 0x02030000
00927 typedef destructor freefunc;
00928 #endif
00929 
00930 #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
00931      (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
00932      (PY_MAJOR_VERSION > 3))
00933 # define SWIGPY_USE_CAPSULE
00934 # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
00935 #endif
00936 
00937 #if PY_VERSION_HEX < 0x03020000
00938 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
00939 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
00940 #endif
00941 
00942 /* -----------------------------------------------------------------------------
00943  * error manipulation
00944  * ----------------------------------------------------------------------------- */
00945 
00946 SWIGRUNTIME PyObject*
00947 SWIG_Python_ErrorType(int code) {
00948   PyObject* type = 0;
00949   switch(code) {
00950   case SWIG_MemoryError:
00951     type = PyExc_MemoryError;
00952     break;
00953   case SWIG_IOError:
00954     type = PyExc_IOError;
00955     break;
00956   case SWIG_RuntimeError:
00957     type = PyExc_RuntimeError;
00958     break;
00959   case SWIG_IndexError:
00960     type = PyExc_IndexError;
00961     break;
00962   case SWIG_TypeError:
00963     type = PyExc_TypeError;
00964     break;
00965   case SWIG_DivisionByZero:
00966     type = PyExc_ZeroDivisionError;
00967     break;
00968   case SWIG_OverflowError:
00969     type = PyExc_OverflowError;
00970     break;
00971   case SWIG_SyntaxError:
00972     type = PyExc_SyntaxError;
00973     break;
00974   case SWIG_ValueError:
00975     type = PyExc_ValueError;
00976     break;
00977   case SWIG_SystemError:
00978     type = PyExc_SystemError;
00979     break;
00980   case SWIG_AttributeError:
00981     type = PyExc_AttributeError;
00982     break;
00983   default:
00984     type = PyExc_RuntimeError;
00985   }
00986   return type;
00987 }
00988 
00989 
00990 SWIGRUNTIME void
00991 SWIG_Python_AddErrorMsg(const char* mesg)
00992 {
00993   PyObject *type = 0;
00994   PyObject *value = 0;
00995   PyObject *traceback = 0;
00996 
00997   if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
00998   if (value) {
00999     char *tmp;
01000     PyObject *old_str = PyObject_Str(value);
01001     PyErr_Clear();
01002     Py_XINCREF(type);
01003 
01004     PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
01005     SWIG_Python_str_DelForPy3(tmp);
01006     Py_DECREF(old_str);
01007     Py_DECREF(value);
01008   } else {
01009     PyErr_SetString(PyExc_RuntimeError, mesg);
01010   }
01011 }
01012 
01013 #if defined(SWIG_PYTHON_NO_THREADS)
01014 #  if defined(SWIG_PYTHON_THREADS)
01015 #    undef SWIG_PYTHON_THREADS
01016 #  endif
01017 #endif
01018 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
01019 #  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
01020 #    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
01021 #      define SWIG_PYTHON_USE_GIL
01022 #    endif
01023 #  endif
01024 #  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
01025 #    ifndef SWIG_PYTHON_INITIALIZE_THREADS
01026 #     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads() 
01027 #    endif
01028 #    ifdef __cplusplus /* C++ code */
01029        class SWIG_Python_Thread_Block {
01030          bool status;
01031          PyGILState_STATE state;
01032        public:
01033          void end() { if (status) { PyGILState_Release(state); status = false;} }
01034          SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
01035          ~SWIG_Python_Thread_Block() { end(); }
01036        };
01037        class SWIG_Python_Thread_Allow {
01038          bool status;
01039          PyThreadState *save;
01040        public:
01041          void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
01042          SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
01043          ~SWIG_Python_Thread_Allow() { end(); }
01044        };
01045 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
01046 #      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
01047 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
01048 #      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
01049 #    else /* C code */
01050 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
01051 #      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
01052 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
01053 #      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
01054 #    endif
01055 #  else /* Old thread way, not implemented, user must provide it */
01056 #    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
01057 #      define SWIG_PYTHON_INITIALIZE_THREADS
01058 #    endif
01059 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
01060 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
01061 #    endif
01062 #    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
01063 #      define SWIG_PYTHON_THREAD_END_BLOCK
01064 #    endif
01065 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
01066 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
01067 #    endif
01068 #    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
01069 #      define SWIG_PYTHON_THREAD_END_ALLOW
01070 #    endif
01071 #  endif
01072 #else /* No thread support */
01073 #  define SWIG_PYTHON_INITIALIZE_THREADS
01074 #  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
01075 #  define SWIG_PYTHON_THREAD_END_BLOCK
01076 #  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
01077 #  define SWIG_PYTHON_THREAD_END_ALLOW
01078 #endif
01079 
01080 /* -----------------------------------------------------------------------------
01081  * Python API portion that goes into the runtime
01082  * ----------------------------------------------------------------------------- */
01083 
01084 #ifdef __cplusplus
01085 extern "C" {
01086 #endif
01087 
01088 /* -----------------------------------------------------------------------------
01089  * Constant declarations
01090  * ----------------------------------------------------------------------------- */
01091 
01092 /* Constant Types */
01093 #define SWIG_PY_POINTER 4
01094 #define SWIG_PY_BINARY  5
01095 
01096 /* Constant information structure */
01097 typedef struct swig_const_info {
01098   int type;
01099   char *name;
01100   long lvalue;
01101   double dvalue;
01102   void   *pvalue;
01103   swig_type_info **ptype;
01104 } swig_const_info;
01105 
01106 
01107 /* -----------------------------------------------------------------------------
01108  * Wrapper of PyInstanceMethod_New() used in Python 3
01109  * It is exported to the generated module, used for -fastproxy
01110  * ----------------------------------------------------------------------------- */
01111 #if PY_VERSION_HEX >= 0x03000000
01112 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
01113 {
01114   return PyInstanceMethod_New(func);
01115 }
01116 #else
01117 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
01118 {
01119   return NULL;
01120 }
01121 #endif
01122 
01123 #ifdef __cplusplus
01124 }
01125 #endif
01126 
01127 
01128 /* -----------------------------------------------------------------------------
01129  * pyrun.swg
01130  *
01131  * This file contains the runtime support for Python modules
01132  * and includes code for managing global variables and pointer
01133  * type checking.
01134  *
01135  * ----------------------------------------------------------------------------- */
01136 
01137 /* Common SWIG API */
01138 
01139 /* for raw pointers */
01140 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
01141 #define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
01142 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
01143 
01144 #ifdef SWIGPYTHON_BUILTIN
01145 #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(self, ptr, type, flags)
01146 #else
01147 #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
01148 #endif
01149 
01150 #define SWIG_InternalNewPointerObj(ptr, type, flags)    SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
01151 
01152 #define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
01153 #define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
01154 #define swig_owntype                                    int
01155 
01156 /* for raw packed data */
01157 #define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
01158 #define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
01159 
01160 /* for class or struct pointers */
01161 #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
01162 #define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
01163 
01164 /* for C or C++ function pointers */
01165 #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
01166 #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
01167 
01168 /* for C++ member pointers, ie, member methods */
01169 #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
01170 #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
01171 
01172 
01173 /* Runtime API */
01174 
01175 #define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule(clientdata)
01176 #define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
01177 #define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)
01178 
01179 #define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
01180 #define SWIG_SetErrorMsg                                SWIG_Python_SetErrorMsg                            
01181 #define SWIG_ErrorType(code)                            SWIG_Python_ErrorType(code)                        
01182 #define SWIG_Error(code, msg)                           SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 
01183 #define SWIG_fail                                       goto fail                                          
01184 
01185 
01186 /* Runtime API implementation */
01187 
01188 /* Error manipulation */
01189 
01190 SWIGINTERN void 
01191 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
01192   SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
01193   PyErr_SetObject(errtype, obj);
01194   Py_DECREF(obj);
01195   SWIG_PYTHON_THREAD_END_BLOCK;
01196 }
01197 
01198 SWIGINTERN void 
01199 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
01200   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
01201   PyErr_SetString(errtype, msg);
01202   SWIG_PYTHON_THREAD_END_BLOCK;
01203 }
01204 
01205 #define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
01206 
01207 /* Set a constant value */
01208 
01209 #if defined(SWIGPYTHON_BUILTIN)
01210 
01211 SWIGINTERN void
01212 SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
01213   PyObject *s = PyString_InternFromString(key);
01214   PyList_Append(seq, s);
01215   Py_DECREF(s);
01216 }
01217 
01218 SWIGINTERN void
01219 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {   
01220 #if PY_VERSION_HEX < 0x02030000
01221   PyDict_SetItemString(d, (char *)name, obj);
01222 #else
01223   PyDict_SetItemString(d, name, obj);
01224 #endif
01225   Py_DECREF(obj);
01226   if (public_interface)
01227     SwigPyBuiltin_AddPublicSymbol(public_interface, name);
01228 }
01229 
01230 #else
01231 
01232 SWIGINTERN void
01233 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
01234 #if PY_VERSION_HEX < 0x02030000
01235   PyDict_SetItemString(d, (char *)name, obj);
01236 #else
01237   PyDict_SetItemString(d, name, obj);
01238 #endif
01239   Py_DECREF(obj);                            
01240 }
01241 
01242 #endif
01243 
01244 /* Append a value to the result obj */
01245 
01246 SWIGINTERN PyObject*
01247 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
01248 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
01249   if (!result) {
01250     result = obj;
01251   } else if (result == Py_None) {
01252     Py_DECREF(result);
01253     result = obj;
01254   } else {
01255     if (!PyList_Check(result)) {
01256       PyObject *o2 = result;
01257       result = PyList_New(1);
01258       PyList_SetItem(result, 0, o2);
01259     }
01260     PyList_Append(result,obj);
01261     Py_DECREF(obj);
01262   }
01263   return result;
01264 #else
01265   PyObject*   o2;
01266   PyObject*   o3;
01267   if (!result) {
01268     result = obj;
01269   } else if (result == Py_None) {
01270     Py_DECREF(result);
01271     result = obj;
01272   } else {
01273     if (!PyTuple_Check(result)) {
01274       o2 = result;
01275       result = PyTuple_New(1);
01276       PyTuple_SET_ITEM(result, 0, o2);
01277     }
01278     o3 = PyTuple_New(1);
01279     PyTuple_SET_ITEM(o3, 0, obj);
01280     o2 = result;
01281     result = PySequence_Concat(o2, o3);
01282     Py_DECREF(o2);
01283     Py_DECREF(o3);
01284   }
01285   return result;
01286 #endif
01287 }
01288 
01289 /* Unpack the argument tuple */
01290 
01291 SWIGINTERN int
01292 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
01293 {
01294   if (!args) {
01295     if (!min && !max) {
01296       return 1;
01297     } else {
01298       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
01299                    name, (min == max ? "" : "at least "), (int)min);
01300       return 0;
01301     }
01302   }  
01303   if (!PyTuple_Check(args)) {
01304     if (min <= 1 && max >= 1) {
01305       int i;
01306       objs[0] = args;
01307       for (i = 1; i < max; ++i) {
01308         objs[i] = 0;
01309       }
01310       return 2;
01311     }
01312     PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
01313     return 0;
01314   } else {
01315     Py_ssize_t l = PyTuple_GET_SIZE(args);
01316     if (l < min) {
01317       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
01318                    name, (min == max ? "" : "at least "), (int)min, (int)l);
01319       return 0;
01320     } else if (l > max) {
01321       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
01322                    name, (min == max ? "" : "at most "), (int)max, (int)l);
01323       return 0;
01324     } else {
01325       int i;
01326       for (i = 0; i < l; ++i) {
01327         objs[i] = PyTuple_GET_ITEM(args, i);
01328       }
01329       for (; l < max; ++l) {
01330         objs[l] = 0;
01331       }
01332       return i + 1;
01333     }    
01334   }
01335 }
01336 
01337 /* A functor is a function object with one single object argument */
01338 #if PY_VERSION_HEX >= 0x02020000
01339 #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunctionObjArgs(functor, obj, NULL);
01340 #else
01341 #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunction(functor, "O", obj);
01342 #endif
01343 
01344 /*
01345   Helper for static pointer initialization for both C and C++ code, for example
01346   static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
01347 */
01348 #ifdef __cplusplus
01349 #define SWIG_STATIC_POINTER(var)  var
01350 #else
01351 #define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
01352 #endif
01353 
01354 /* -----------------------------------------------------------------------------
01355  * Pointer declarations
01356  * ----------------------------------------------------------------------------- */
01357 
01358 /* Flags for new pointer objects */
01359 #define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
01360 #define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
01361 
01362 #define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
01363 
01364 #define SWIG_BUILTIN_TP_INIT        (SWIG_POINTER_OWN << 2)
01365 #define SWIG_BUILTIN_INIT           (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
01366 
01367 #ifdef __cplusplus
01368 extern "C" {
01369 #endif
01370 
01371 /*  How to access Py_None */
01372 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
01373 #  ifndef SWIG_PYTHON_NO_BUILD_NONE
01374 #    ifndef SWIG_PYTHON_BUILD_NONE
01375 #      define SWIG_PYTHON_BUILD_NONE
01376 #    endif
01377 #  endif
01378 #endif
01379 
01380 #ifdef SWIG_PYTHON_BUILD_NONE
01381 #  ifdef Py_None
01382 #   undef Py_None
01383 #   define Py_None SWIG_Py_None()
01384 #  endif
01385 SWIGRUNTIMEINLINE PyObject * 
01386 _SWIG_Py_None(void)
01387 {
01388   PyObject *none = Py_BuildValue((char*)"");
01389   Py_DECREF(none);
01390   return none;
01391 }
01392 SWIGRUNTIME PyObject * 
01393 SWIG_Py_None(void)
01394 {
01395   static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
01396   return none;
01397 }
01398 #endif
01399 
01400 /* The python void return value */
01401 
01402 SWIGRUNTIMEINLINE PyObject * 
01403 SWIG_Py_Void(void)
01404 {
01405   PyObject *none = Py_None;
01406   Py_INCREF(none);
01407   return none;
01408 }
01409 
01410 /* SwigPyClientData */
01411 
01412 typedef struct {
01413   PyObject *klass;
01414   PyObject *newraw;
01415   PyObject *newargs;
01416   PyObject *destroy;
01417   int delargs;
01418   int implicitconv;
01419   PyTypeObject *pytype;
01420 } SwigPyClientData;
01421 
01422 SWIGRUNTIMEINLINE int 
01423 SWIG_Python_CheckImplicit(swig_type_info *ty)
01424 {
01425   SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
01426   return data ? data->implicitconv : 0;
01427 }
01428 
01429 SWIGRUNTIMEINLINE PyObject *
01430 SWIG_Python_ExceptionType(swig_type_info *desc) {
01431   SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
01432   PyObject *klass = data ? data->klass : 0;
01433   return (klass ? klass : PyExc_RuntimeError);
01434 }
01435 
01436 
01437 SWIGRUNTIME SwigPyClientData * 
01438 SwigPyClientData_New(PyObject* obj)
01439 {
01440   if (!obj) {
01441     return 0;
01442   } else {
01443     SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
01444     /* the klass element */
01445     data->klass = obj;
01446     Py_INCREF(data->klass);
01447     /* the newraw method and newargs arguments used to create a new raw instance */
01448     if (PyClass_Check(obj)) {
01449       data->newraw = 0;
01450       data->newargs = obj;
01451       Py_INCREF(obj);
01452     } else {
01453 #if (PY_VERSION_HEX < 0x02020000)
01454       data->newraw = 0;
01455 #else
01456       data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
01457 #endif
01458       if (data->newraw) {
01459         Py_INCREF(data->newraw);
01460         data->newargs = PyTuple_New(1);
01461         PyTuple_SetItem(data->newargs, 0, obj);
01462       } else {
01463         data->newargs = obj;
01464       }
01465       Py_INCREF(data->newargs);
01466     }
01467     /* the destroy method, aka as the C++ delete method */
01468     data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
01469     if (PyErr_Occurred()) {
01470       PyErr_Clear();
01471       data->destroy = 0;
01472     }
01473     if (data->destroy) {
01474       int flags;
01475       Py_INCREF(data->destroy);
01476       flags = PyCFunction_GET_FLAGS(data->destroy);
01477 #ifdef METH_O
01478       data->delargs = !(flags & (METH_O));
01479 #else
01480       data->delargs = 0;
01481 #endif
01482     } else {
01483       data->delargs = 0;
01484     }
01485     data->implicitconv = 0;
01486     data->pytype = 0;
01487     return data;
01488   }
01489 }
01490 
01491 SWIGRUNTIME void 
01492 SwigPyClientData_Del(SwigPyClientData *data) {
01493   Py_XDECREF(data->newraw);
01494   Py_XDECREF(data->newargs);
01495   Py_XDECREF(data->destroy);
01496 }
01497 
01498 /* =============== SwigPyObject =====================*/
01499 
01500 typedef struct {
01501   PyObject_HEAD
01502   void *ptr;
01503   swig_type_info *ty;
01504   int own;
01505   PyObject *next;
01506 #ifdef SWIGPYTHON_BUILTIN
01507   PyObject *dict;
01508 #endif
01509 } SwigPyObject;
01510 
01511 SWIGRUNTIME PyObject *
01512 SwigPyObject_long(SwigPyObject *v)
01513 {
01514   return PyLong_FromVoidPtr(v->ptr);
01515 }
01516 
01517 SWIGRUNTIME PyObject *
01518 SwigPyObject_format(const char* fmt, SwigPyObject *v)
01519 {
01520   PyObject *res = NULL;
01521   PyObject *args = PyTuple_New(1);
01522   if (args) {
01523     if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
01524       PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
01525       if (ofmt) {
01526 #if PY_VERSION_HEX >= 0x03000000
01527         res = PyUnicode_Format(ofmt,args);
01528 #else
01529         res = PyString_Format(ofmt,args);
01530 #endif
01531         Py_DECREF(ofmt);
01532       }
01533       Py_DECREF(args);
01534     }
01535   }
01536   return res;
01537 }
01538 
01539 SWIGRUNTIME PyObject *
01540 SwigPyObject_oct(SwigPyObject *v)
01541 {
01542   return SwigPyObject_format("%o",v);
01543 }
01544 
01545 SWIGRUNTIME PyObject *
01546 SwigPyObject_hex(SwigPyObject *v)
01547 {
01548   return SwigPyObject_format("%x",v);
01549 }
01550 
01551 SWIGRUNTIME PyObject *
01552 #ifdef METH_NOARGS
01553 SwigPyObject_repr(SwigPyObject *v)
01554 #else
01555 SwigPyObject_repr(SwigPyObject *v, PyObject *args)
01556 #endif
01557 {
01558   const char *name = SWIG_TypePrettyName(v->ty);
01559   PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
01560   if (v->next) {
01561 # ifdef METH_NOARGS
01562     PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
01563 # else
01564     PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
01565 # endif
01566 # if PY_VERSION_HEX >= 0x03000000
01567     PyObject *joined = PyUnicode_Concat(repr, nrep);
01568     Py_DecRef(repr);
01569     Py_DecRef(nrep);
01570     repr = joined;
01571 # else
01572     PyString_ConcatAndDel(&repr,nrep);
01573 # endif
01574   }
01575   return repr;  
01576 }
01577 
01578 SWIGRUNTIME int
01579 SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
01580 {
01581   void *i = v->ptr;
01582   void *j = w->ptr;
01583   return (i < j) ? -1 : ((i > j) ? 1 : 0);
01584 }
01585 
01586 /* Added for Python 3.x, would it also be useful for Python 2.x? */
01587 SWIGRUNTIME PyObject*
01588 SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
01589 {
01590   PyObject* res;
01591   if( op != Py_EQ && op != Py_NE ) {
01592     Py_INCREF(Py_NotImplemented);
01593     return Py_NotImplemented;
01594   }
01595   res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
01596   return res;  
01597 }
01598 
01599 
01600 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
01601 
01602 #ifdef SWIGPYTHON_BUILTIN
01603 static swig_type_info *SwigPyObject_stype = 0;
01604 SWIGRUNTIME PyTypeObject*
01605 SwigPyObject_type(void) {
01606     SwigPyClientData *cd;
01607     assert(SwigPyObject_stype);
01608     cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
01609     assert(cd);
01610     assert(cd->pytype);
01611     return cd->pytype;
01612 }
01613 #else
01614 SWIGRUNTIME PyTypeObject*
01615 SwigPyObject_type(void) {
01616   static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
01617   return type;
01618 }
01619 #endif
01620 
01621 SWIGRUNTIMEINLINE int
01622 SwigPyObject_Check(PyObject *op) {
01623 #ifdef SWIGPYTHON_BUILTIN
01624   PyTypeObject *target_tp = SwigPyObject_type();
01625   if (PyType_IsSubtype(op->ob_type, target_tp))
01626     return 1;
01627   return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
01628 #else
01629   return (Py_TYPE(op) == SwigPyObject_type())
01630     || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
01631 #endif
01632 }
01633 
01634 SWIGRUNTIME PyObject *
01635 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
01636 
01637 SWIGRUNTIME void
01638 SwigPyObject_dealloc(PyObject *v)
01639 {
01640   SwigPyObject *sobj = (SwigPyObject *) v;
01641   PyObject *next = sobj->next;
01642   if (sobj->own == SWIG_POINTER_OWN) {
01643     swig_type_info *ty = sobj->ty;
01644     SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
01645     PyObject *destroy = data ? data->destroy : 0;
01646     if (destroy) {
01647       /* destroy is always a VARARGS method */
01648       PyObject *res;
01649       if (data->delargs) {
01650         /* we need to create a temporary object to carry the destroy operation */
01651         PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
01652         res = SWIG_Python_CallFunctor(destroy, tmp);
01653         Py_DECREF(tmp);
01654       } else {
01655         PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
01656         PyObject *mself = PyCFunction_GET_SELF(destroy);
01657         res = ((*meth)(mself, v));
01658       }
01659       Py_XDECREF(res);
01660     } 
01661 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
01662     else {
01663       const char *name = SWIG_TypePrettyName(ty);
01664       printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
01665     }
01666 #endif
01667   } 
01668   Py_XDECREF(next);
01669   PyObject_DEL(v);
01670 }
01671 
01672 SWIGRUNTIME PyObject* 
01673 SwigPyObject_append(PyObject* v, PyObject* next)
01674 {
01675   SwigPyObject *sobj = (SwigPyObject *) v;
01676 #ifndef METH_O
01677   PyObject *tmp = 0;
01678   if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
01679   next = tmp;
01680 #endif
01681   if (!SwigPyObject_Check(next)) {
01682     return NULL;
01683   }
01684   sobj->next = next;
01685   Py_INCREF(next);
01686   return SWIG_Py_Void();
01687 }
01688 
01689 SWIGRUNTIME PyObject* 
01690 #ifdef METH_NOARGS
01691 SwigPyObject_next(PyObject* v)
01692 #else
01693 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
01694 #endif
01695 {
01696   SwigPyObject *sobj = (SwigPyObject *) v;
01697   if (sobj->next) {    
01698     Py_INCREF(sobj->next);
01699     return sobj->next;
01700   } else {
01701     return SWIG_Py_Void();
01702   }
01703 }
01704 
01705 SWIGINTERN PyObject*
01706 #ifdef METH_NOARGS
01707 SwigPyObject_disown(PyObject *v)
01708 #else
01709 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
01710 #endif
01711 {
01712   SwigPyObject *sobj = (SwigPyObject *)v;
01713   sobj->own = 0;
01714   return SWIG_Py_Void();
01715 }
01716 
01717 SWIGINTERN PyObject*
01718 #ifdef METH_NOARGS
01719 SwigPyObject_acquire(PyObject *v)
01720 #else
01721 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
01722 #endif
01723 {
01724   SwigPyObject *sobj = (SwigPyObject *)v;
01725   sobj->own = SWIG_POINTER_OWN;
01726   return SWIG_Py_Void();
01727 }
01728 
01729 SWIGINTERN PyObject*
01730 SwigPyObject_own(PyObject *v, PyObject *args)
01731 {
01732   PyObject *val = 0;
01733 #if (PY_VERSION_HEX < 0x02020000)
01734   if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
01735 #elif (PY_VERSION_HEX < 0x02050000)
01736   if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) 
01737 #else
01738   if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) 
01739 #endif
01740     {
01741       return NULL;
01742     } 
01743   else
01744     {
01745       SwigPyObject *sobj = (SwigPyObject *)v;
01746       PyObject *obj = PyBool_FromLong(sobj->own);
01747       if (val) {
01748 #ifdef METH_NOARGS
01749         if (PyObject_IsTrue(val)) {
01750           SwigPyObject_acquire(v);
01751         } else {
01752           SwigPyObject_disown(v);
01753         }
01754 #else
01755         if (PyObject_IsTrue(val)) {
01756           SwigPyObject_acquire(v,args);
01757         } else {
01758           SwigPyObject_disown(v,args);
01759         }
01760 #endif
01761       } 
01762       return obj;
01763     }
01764 }
01765 
01766 #ifdef METH_O
01767 static PyMethodDef
01768 swigobject_methods[] = {
01769   {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
01770   {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"acquires ownership of the pointer"},
01771   {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
01772   {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)"appends another 'this' object"},
01773   {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
01774   {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
01775   {0, 0, 0, 0}  
01776 };
01777 #else
01778 static PyMethodDef
01779 swigobject_methods[] = {
01780   {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
01781   {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
01782   {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
01783   {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
01784   {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
01785   {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
01786   {0, 0, 0, 0}  
01787 };
01788 #endif
01789 
01790 #if PY_VERSION_HEX < 0x02020000
01791 SWIGINTERN PyObject *
01792 SwigPyObject_getattr(SwigPyObject *sobj,char *name)
01793 {
01794   return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
01795 }
01796 #endif
01797 
01798 SWIGRUNTIME PyTypeObject*
01799 SwigPyObject_TypeOnce(void) {
01800   static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
01801 
01802   static PyNumberMethods SwigPyObject_as_number = {
01803     (binaryfunc)0, /*nb_add*/
01804     (binaryfunc)0, /*nb_subtract*/
01805     (binaryfunc)0, /*nb_multiply*/
01806     /* nb_divide removed in Python 3 */
01807 #if PY_VERSION_HEX < 0x03000000
01808     (binaryfunc)0, /*nb_divide*/
01809 #endif
01810     (binaryfunc)0, /*nb_remainder*/
01811     (binaryfunc)0, /*nb_divmod*/
01812     (ternaryfunc)0,/*nb_power*/
01813     (unaryfunc)0,  /*nb_negative*/
01814     (unaryfunc)0,  /*nb_positive*/
01815     (unaryfunc)0,  /*nb_absolute*/
01816     (inquiry)0,    /*nb_nonzero*/
01817     0,             /*nb_invert*/
01818     0,             /*nb_lshift*/
01819     0,             /*nb_rshift*/
01820     0,             /*nb_and*/
01821     0,             /*nb_xor*/
01822     0,             /*nb_or*/
01823 #if PY_VERSION_HEX < 0x03000000
01824     0,   /*nb_coerce*/
01825 #endif
01826     (unaryfunc)SwigPyObject_long, /*nb_int*/
01827 #if PY_VERSION_HEX < 0x03000000
01828     (unaryfunc)SwigPyObject_long, /*nb_long*/
01829 #else
01830     0, /*nb_reserved*/
01831 #endif
01832     (unaryfunc)0,                 /*nb_float*/
01833 #if PY_VERSION_HEX < 0x03000000
01834     (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
01835     (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
01836 #endif
01837 #if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
01838     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
01839 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
01840     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
01841 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
01842     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
01843 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
01844     0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
01845 #endif
01846   };
01847 
01848   static PyTypeObject swigpyobject_type;
01849   static int type_init = 0;
01850   if (!type_init) {
01851     const PyTypeObject tmp = {
01852       /* PyObject header changed in Python 3 */
01853 #if PY_VERSION_HEX >= 0x03000000
01854       PyVarObject_HEAD_INIT(NULL, 0)
01855 #else
01856       PyObject_HEAD_INIT(NULL)
01857       0,                                    /* ob_size */
01858 #endif
01859       (char *)"SwigPyObject",               /* tp_name */
01860       sizeof(SwigPyObject),                 /* tp_basicsize */
01861       0,                                    /* tp_itemsize */
01862       (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
01863       0,                                    /* tp_print */
01864 #if PY_VERSION_HEX < 0x02020000
01865       (getattrfunc)SwigPyObject_getattr,    /* tp_getattr */
01866 #else
01867       (getattrfunc)0,                       /* tp_getattr */
01868 #endif
01869       (setattrfunc)0,                       /* tp_setattr */
01870 #if PY_VERSION_HEX >= 0x03000000
01871     0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
01872 #else
01873       (cmpfunc)SwigPyObject_compare,        /* tp_compare */
01874 #endif
01875       (reprfunc)SwigPyObject_repr,          /* tp_repr */
01876       &SwigPyObject_as_number,              /* tp_as_number */
01877       0,                                    /* tp_as_sequence */
01878       0,                                    /* tp_as_mapping */
01879       (hashfunc)0,                          /* tp_hash */
01880       (ternaryfunc)0,                       /* tp_call */
01881       0,                                    /* tp_str */
01882       PyObject_GenericGetAttr,              /* tp_getattro */
01883       0,                                    /* tp_setattro */
01884       0,                                    /* tp_as_buffer */
01885       Py_TPFLAGS_DEFAULT,                   /* tp_flags */
01886       swigobject_doc,                       /* tp_doc */
01887       0,                                    /* tp_traverse */
01888       0,                                    /* tp_clear */
01889       (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
01890       0,                                    /* tp_weaklistoffset */
01891 #if PY_VERSION_HEX >= 0x02020000
01892       0,                                    /* tp_iter */
01893       0,                                    /* tp_iternext */
01894       swigobject_methods,                   /* tp_methods */
01895       0,                                    /* tp_members */
01896       0,                                    /* tp_getset */
01897       0,                                    /* tp_base */
01898       0,                                    /* tp_dict */
01899       0,                                    /* tp_descr_get */
01900       0,                                    /* tp_descr_set */
01901       0,                                    /* tp_dictoffset */
01902       0,                                    /* tp_init */
01903       0,                                    /* tp_alloc */
01904       0,                                    /* tp_new */
01905       0,                                    /* tp_free */
01906       0,                                    /* tp_is_gc */
01907       0,                                    /* tp_bases */
01908       0,                                    /* tp_mro */
01909       0,                                    /* tp_cache */
01910       0,                                    /* tp_subclasses */
01911       0,                                    /* tp_weaklist */
01912 #endif
01913 #if PY_VERSION_HEX >= 0x02030000
01914       0,                                    /* tp_del */
01915 #endif
01916 #if PY_VERSION_HEX >= 0x02060000
01917       0,                                    /* tp_version */
01918 #endif
01919 #ifdef COUNT_ALLOCS
01920       0,0,0,0                               /* tp_alloc -> tp_next */
01921 #endif
01922     };
01923     swigpyobject_type = tmp;
01924     type_init = 1;
01925 #if PY_VERSION_HEX < 0x02020000
01926     swigpyobject_type.ob_type = &PyType_Type;
01927 #else
01928     if (PyType_Ready(&swigpyobject_type) < 0)
01929       return NULL;
01930 #endif
01931   }
01932   return &swigpyobject_type;
01933 }
01934 
01935 SWIGRUNTIME PyObject *
01936 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
01937 {
01938   SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
01939   if (sobj) {
01940     sobj->ptr  = ptr;
01941     sobj->ty   = ty;
01942     sobj->own  = own;
01943     sobj->next = 0;
01944   }
01945   return (PyObject *)sobj;
01946 }
01947 
01948 /* -----------------------------------------------------------------------------
01949  * Implements a simple Swig Packed type, and use it instead of string
01950  * ----------------------------------------------------------------------------- */
01951 
01952 typedef struct {
01953   PyObject_HEAD
01954   void *pack;
01955   swig_type_info *ty;
01956   size_t size;
01957 } SwigPyPacked;
01958 
01959 SWIGRUNTIME int
01960 SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
01961 {
01962   char result[SWIG_BUFFER_SIZE];
01963   fputs("<Swig Packed ", fp); 
01964   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
01965     fputs("at ", fp); 
01966     fputs(result, fp); 
01967   }
01968   fputs(v->ty->name,fp); 
01969   fputs(">", fp);
01970   return 0; 
01971 }
01972   
01973 SWIGRUNTIME PyObject *
01974 SwigPyPacked_repr(SwigPyPacked *v)
01975 {
01976   char result[SWIG_BUFFER_SIZE];
01977   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
01978     return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
01979   } else {
01980     return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
01981   }  
01982 }
01983 
01984 SWIGRUNTIME PyObject *
01985 SwigPyPacked_str(SwigPyPacked *v)
01986 {
01987   char result[SWIG_BUFFER_SIZE];
01988   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
01989     return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
01990   } else {
01991     return SWIG_Python_str_FromChar(v->ty->name);
01992   }  
01993 }
01994 
01995 SWIGRUNTIME int
01996 SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
01997 {
01998   size_t i = v->size;
01999   size_t j = w->size;
02000   int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
02001   return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
02002 }
02003 
02004 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
02005 
02006 SWIGRUNTIME PyTypeObject*
02007 SwigPyPacked_type(void) {
02008   static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
02009   return type;
02010 }
02011 
02012 SWIGRUNTIMEINLINE int
02013 SwigPyPacked_Check(PyObject *op) {
02014   return ((op)->ob_type == SwigPyPacked_TypeOnce()) 
02015     || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
02016 }
02017 
02018 SWIGRUNTIME void
02019 SwigPyPacked_dealloc(PyObject *v)
02020 {
02021   if (SwigPyPacked_Check(v)) {
02022     SwigPyPacked *sobj = (SwigPyPacked *) v;
02023     free(sobj->pack);
02024   }
02025   PyObject_DEL(v);
02026 }
02027 
02028 SWIGRUNTIME PyTypeObject*
02029 SwigPyPacked_TypeOnce(void) {
02030   static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
02031   static PyTypeObject swigpypacked_type;
02032   static int type_init = 0;
02033   if (!type_init) {
02034     const PyTypeObject tmp = {
02035       /* PyObject header changed in Python 3 */
02036 #if PY_VERSION_HEX>=0x03000000
02037       PyVarObject_HEAD_INIT(NULL, 0)
02038 #else
02039       PyObject_HEAD_INIT(NULL)
02040       0,                                    /* ob_size */
02041 #endif
02042       (char *)"SwigPyPacked",               /* tp_name */
02043       sizeof(SwigPyPacked),                 /* tp_basicsize */
02044       0,                                    /* tp_itemsize */
02045       (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
02046       (printfunc)SwigPyPacked_print,        /* tp_print */
02047       (getattrfunc)0,                       /* tp_getattr */
02048       (setattrfunc)0,                       /* tp_setattr */
02049 #if PY_VERSION_HEX>=0x03000000
02050       0, /* tp_reserved in 3.0.1 */
02051 #else
02052       (cmpfunc)SwigPyPacked_compare,        /* tp_compare */
02053 #endif
02054       (reprfunc)SwigPyPacked_repr,          /* tp_repr */
02055       0,                                    /* tp_as_number */
02056       0,                                    /* tp_as_sequence */
02057       0,                                    /* tp_as_mapping */
02058       (hashfunc)0,                          /* tp_hash */
02059       (ternaryfunc)0,                       /* tp_call */
02060       (reprfunc)SwigPyPacked_str,           /* tp_str */
02061       PyObject_GenericGetAttr,              /* tp_getattro */
02062       0,                                    /* tp_setattro */
02063       0,                                    /* tp_as_buffer */
02064       Py_TPFLAGS_DEFAULT,                   /* tp_flags */
02065       swigpacked_doc,                       /* tp_doc */
02066       0,                                    /* tp_traverse */
02067       0,                                    /* tp_clear */
02068       0,                                    /* tp_richcompare */
02069       0,                                    /* tp_weaklistoffset */
02070 #if PY_VERSION_HEX >= 0x02020000
02071       0,                                    /* tp_iter */
02072       0,                                    /* tp_iternext */
02073       0,                                    /* tp_methods */
02074       0,                                    /* tp_members */
02075       0,                                    /* tp_getset */
02076       0,                                    /* tp_base */
02077       0,                                    /* tp_dict */
02078       0,                                    /* tp_descr_get */
02079       0,                                    /* tp_descr_set */
02080       0,                                    /* tp_dictoffset */
02081       0,                                    /* tp_init */
02082       0,                                    /* tp_alloc */
02083       0,                                    /* tp_new */
02084       0,                                    /* tp_free */
02085       0,                                    /* tp_is_gc */
02086       0,                                    /* tp_bases */
02087       0,                                    /* tp_mro */
02088       0,                                    /* tp_cache */
02089       0,                                    /* tp_subclasses */
02090       0,                                    /* tp_weaklist */
02091 #endif
02092 #if PY_VERSION_HEX >= 0x02030000
02093       0,                                    /* tp_del */
02094 #endif
02095 #if PY_VERSION_HEX >= 0x02060000
02096       0,                                    /* tp_version */
02097 #endif
02098 #ifdef COUNT_ALLOCS
02099       0,0,0,0                               /* tp_alloc -> tp_next */
02100 #endif
02101     };
02102     swigpypacked_type = tmp;
02103     type_init = 1;
02104 #if PY_VERSION_HEX < 0x02020000
02105     swigpypacked_type.ob_type = &PyType_Type;
02106 #else
02107     if (PyType_Ready(&swigpypacked_type) < 0)
02108       return NULL;
02109 #endif
02110   }
02111   return &swigpypacked_type;
02112 }
02113 
02114 SWIGRUNTIME PyObject *
02115 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
02116 {
02117   SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
02118   if (sobj) {
02119     void *pack = malloc(size);
02120     if (pack) {
02121       memcpy(pack, ptr, size);
02122       sobj->pack = pack;
02123       sobj->ty   = ty;
02124       sobj->size = size;
02125     } else {
02126       PyObject_DEL((PyObject *) sobj);
02127       sobj = 0;
02128     }
02129   }
02130   return (PyObject *) sobj;
02131 }
02132 
02133 SWIGRUNTIME swig_type_info *
02134 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
02135 {
02136   if (SwigPyPacked_Check(obj)) {
02137     SwigPyPacked *sobj = (SwigPyPacked *)obj;
02138     if (sobj->size != size) return 0;
02139     memcpy(ptr, sobj->pack, size);
02140     return sobj->ty;
02141   } else {
02142     return 0;
02143   }
02144 }
02145 
02146 /* -----------------------------------------------------------------------------
02147  * pointers/data manipulation
02148  * ----------------------------------------------------------------------------- */
02149 
02150 SWIGRUNTIMEINLINE PyObject *
02151 _SWIG_This(void)
02152 {
02153     return SWIG_Python_str_FromChar("this");
02154 }
02155 
02156 static PyObject *swig_this = NULL;
02157 
02158 SWIGRUNTIME PyObject *
02159 SWIG_This(void)
02160 {
02161   if (swig_this == NULL)
02162     swig_this = _SWIG_This();
02163   return swig_this;
02164 }
02165 
02166 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
02167 
02168 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
02169 #if PY_VERSION_HEX>=0x03000000
02170 #define SWIG_PYTHON_SLOW_GETSET_THIS 
02171 #endif
02172 
02173 SWIGRUNTIME SwigPyObject *
02174 SWIG_Python_GetSwigThis(PyObject *pyobj) 
02175 {
02176   PyObject *obj;
02177 
02178   if (SwigPyObject_Check(pyobj))
02179     return (SwigPyObject *) pyobj;
02180 
02181 #ifdef SWIGPYTHON_BUILTIN
02182   (void)obj;
02183 # ifdef PyWeakref_CheckProxy
02184   if (PyWeakref_CheckProxy(pyobj)) {
02185     pyobj = PyWeakref_GET_OBJECT(pyobj);
02186     if (pyobj && SwigPyObject_Check(pyobj))
02187       return (SwigPyObject*) pyobj;
02188   }
02189 # endif
02190   return NULL;
02191 #else
02192 
02193   obj = 0;
02194 
02195 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
02196   if (PyInstance_Check(pyobj)) {
02197     obj = _PyInstance_Lookup(pyobj, SWIG_This());      
02198   } else {
02199     PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
02200     if (dictptr != NULL) {
02201       PyObject *dict = *dictptr;
02202       obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
02203     } else {
02204 #ifdef PyWeakref_CheckProxy
02205       if (PyWeakref_CheckProxy(pyobj)) {
02206         PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
02207         return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
02208       }
02209 #endif
02210       obj = PyObject_GetAttr(pyobj,SWIG_This());
02211       if (obj) {
02212         Py_DECREF(obj);
02213       } else {
02214         if (PyErr_Occurred()) PyErr_Clear();
02215         return 0;
02216       }
02217     }
02218   }
02219 #else
02220   obj = PyObject_GetAttr(pyobj,SWIG_This());
02221   if (obj) {
02222     Py_DECREF(obj);
02223   } else {
02224     if (PyErr_Occurred()) PyErr_Clear();
02225     return 0;
02226   }
02227 #endif
02228   if (obj && !SwigPyObject_Check(obj)) {
02229     /* a PyObject is called 'this', try to get the 'real this'
02230        SwigPyObject from it */ 
02231     return SWIG_Python_GetSwigThis(obj);
02232   }
02233   return (SwigPyObject *)obj;
02234 #endif
02235 }
02236 
02237 /* Acquire a pointer value */
02238 
02239 SWIGRUNTIME int
02240 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
02241   if (own == SWIG_POINTER_OWN) {
02242     SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
02243     if (sobj) {
02244       int oldown = sobj->own;
02245       sobj->own = own;
02246       return oldown;
02247     }
02248   }
02249   return 0;
02250 }
02251 
02252 /* Convert a pointer value */
02253 
02254 SWIGRUNTIME int
02255 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
02256   int res;
02257   SwigPyObject *sobj;
02258   int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
02259 
02260   if (!obj)
02261     return SWIG_ERROR;
02262   if (obj == Py_None && !implicit_conv) {
02263     if (ptr)
02264       *ptr = 0;
02265     return SWIG_OK;
02266   }
02267 
02268   res = SWIG_ERROR;
02269 
02270   sobj = SWIG_Python_GetSwigThis(obj);
02271   if (own)
02272     *own = 0;
02273   while (sobj) {
02274     void *vptr = sobj->ptr;
02275     if (ty) {
02276       swig_type_info *to = sobj->ty;
02277       if (to == ty) {
02278         /* no type cast needed */
02279         if (ptr) *ptr = vptr;
02280         break;
02281       } else {
02282         swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
02283         if (!tc) {
02284           sobj = (SwigPyObject *)sobj->next;
02285         } else {
02286           if (ptr) {
02287             int newmemory = 0;
02288             *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
02289             if (newmemory == SWIG_CAST_NEW_MEMORY) {
02290               assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
02291               if (own)
02292                 *own = *own | SWIG_CAST_NEW_MEMORY;
02293             }
02294           }
02295           break;
02296         }
02297       }
02298     } else {
02299       if (ptr) *ptr = vptr;
02300       break;
02301     }
02302   }
02303   if (sobj) {
02304     if (own)
02305       *own = *own | sobj->own;
02306     if (flags & SWIG_POINTER_DISOWN) {
02307       sobj->own = 0;
02308     }
02309     res = SWIG_OK;
02310   } else {
02311     if (implicit_conv) {
02312       SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
02313       if (data && !data->implicitconv) {
02314         PyObject *klass = data->klass;
02315         if (klass) {
02316           PyObject *impconv;
02317           data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
02318           impconv = SWIG_Python_CallFunctor(klass, obj);
02319           data->implicitconv = 0;
02320           if (PyErr_Occurred()) {
02321             PyErr_Clear();
02322             impconv = 0;
02323           }
02324           if (impconv) {
02325             SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
02326             if (iobj) {
02327               void *vptr;
02328               res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
02329               if (SWIG_IsOK(res)) {
02330                 if (ptr) {
02331                   *ptr = vptr;
02332                   /* transfer the ownership to 'ptr' */
02333                   iobj->own = 0;
02334                   res = SWIG_AddCast(res);
02335                   res = SWIG_AddNewMask(res);
02336                 } else {
02337                   res = SWIG_AddCast(res);                  
02338                 }
02339               }
02340             }
02341             Py_DECREF(impconv);
02342           }
02343         }
02344       }
02345     }
02346     if (!SWIG_IsOK(res) && obj == Py_None) {
02347       if (ptr)
02348         *ptr = 0;
02349       if (PyErr_Occurred())
02350         PyErr_Clear();
02351       res = SWIG_OK;
02352     }
02353   }
02354   return res;
02355 }
02356 
02357 /* Convert a function ptr value */
02358 
02359 SWIGRUNTIME int
02360 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
02361   if (!PyCFunction_Check(obj)) {
02362     return SWIG_ConvertPtr(obj, ptr, ty, 0);
02363   } else {
02364     void *vptr = 0;
02365     
02366     /* here we get the method pointer for callbacks */
02367     const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
02368     const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
02369     if (desc)
02370       desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
02371     if (!desc) 
02372       return SWIG_ERROR;
02373     if (ty) {
02374       swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
02375       if (tc) {
02376         int newmemory = 0;
02377         *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
02378         assert(!newmemory); /* newmemory handling not yet implemented */
02379       } else {
02380         return SWIG_ERROR;
02381       }
02382     } else {
02383       *ptr = vptr;
02384     }
02385     return SWIG_OK;
02386   }
02387 }
02388 
02389 /* Convert a packed value value */
02390 
02391 SWIGRUNTIME int
02392 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
02393   swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
02394   if (!to) return SWIG_ERROR;
02395   if (ty) {
02396     if (to != ty) {
02397       /* check type cast? */
02398       swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
02399       if (!tc) return SWIG_ERROR;
02400     }
02401   }
02402   return SWIG_OK;
02403 }  
02404 
02405 /* -----------------------------------------------------------------------------
02406  * Create a new pointer object
02407  * ----------------------------------------------------------------------------- */
02408 
02409 /*
02410   Create a new instance object, without calling __init__, and set the
02411   'this' attribute.
02412 */
02413 
02414 SWIGRUNTIME PyObject* 
02415 SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
02416 {
02417 #if (PY_VERSION_HEX >= 0x02020000)
02418   PyObject *inst = 0;
02419   PyObject *newraw = data->newraw;
02420   if (newraw) {
02421     inst = PyObject_Call(newraw, data->newargs, NULL);
02422     if (inst) {
02423 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
02424       PyObject **dictptr = _PyObject_GetDictPtr(inst);
02425       if (dictptr != NULL) {
02426         PyObject *dict = *dictptr;
02427         if (dict == NULL) {
02428           dict = PyDict_New();
02429           *dictptr = dict;
02430           PyDict_SetItem(dict, SWIG_This(), swig_this);
02431         }
02432       }
02433 #else
02434       PyObject *key = SWIG_This();
02435       PyObject_SetAttr(inst, key, swig_this);
02436 #endif
02437     }
02438   } else {
02439 #if PY_VERSION_HEX >= 0x03000000
02440     inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
02441     if (inst) {
02442       PyObject_SetAttr(inst, SWIG_This(), swig_this);
02443       Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
02444     }
02445 #else
02446     PyObject *dict = PyDict_New();
02447     if (dict) {
02448       PyDict_SetItem(dict, SWIG_This(), swig_this);
02449       inst = PyInstance_NewRaw(data->newargs, dict);
02450       Py_DECREF(dict);
02451     }
02452 #endif
02453   }
02454   return inst;
02455 #else
02456 #if (PY_VERSION_HEX >= 0x02010000)
02457   PyObject *inst = 0;
02458   PyObject *dict = PyDict_New();
02459   if (dict) {
02460     PyDict_SetItem(dict, SWIG_This(), swig_this);
02461     inst = PyInstance_NewRaw(data->newargs, dict);
02462     Py_DECREF(dict);
02463   }
02464   return (PyObject *) inst;
02465 #else
02466   PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
02467   if (inst == NULL) {
02468     return NULL;
02469   }
02470   inst->in_class = (PyClassObject *)data->newargs;
02471   Py_INCREF(inst->in_class);
02472   inst->in_dict = PyDict_New();
02473   if (inst->in_dict == NULL) {
02474     Py_DECREF(inst);
02475     return NULL;
02476   }
02477 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
02478   inst->in_weakreflist = NULL;
02479 #endif
02480 #ifdef Py_TPFLAGS_GC
02481   PyObject_GC_Init(inst);
02482 #endif
02483   PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
02484   return (PyObject *) inst;
02485 #endif
02486 #endif
02487 }
02488 
02489 SWIGRUNTIME void
02490 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
02491 {
02492  PyObject *dict;
02493 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
02494  PyObject **dictptr = _PyObject_GetDictPtr(inst);
02495  if (dictptr != NULL) {
02496    dict = *dictptr;
02497    if (dict == NULL) {
02498      dict = PyDict_New();
02499      *dictptr = dict;
02500    }
02501    PyDict_SetItem(dict, SWIG_This(), swig_this);
02502    return;
02503  }
02504 #endif
02505  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
02506  PyDict_SetItem(dict, SWIG_This(), swig_this);
02507  Py_DECREF(dict);
02508 } 
02509 
02510 
02511 SWIGINTERN PyObject *
02512 SWIG_Python_InitShadowInstance(PyObject *args) {
02513   PyObject *obj[2];
02514   if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
02515     return NULL;
02516   } else {
02517     SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
02518     if (sthis) {
02519       SwigPyObject_append((PyObject*) sthis, obj[1]);
02520     } else {
02521       SWIG_Python_SetSwigThis(obj[0], obj[1]);
02522     }
02523     return SWIG_Py_Void();
02524   }
02525 }
02526 
02527 /* Create a new pointer object */
02528 
02529 SWIGRUNTIME PyObject *
02530 SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
02531   SwigPyClientData *clientdata;
02532   PyObject * robj;
02533   int own;
02534 
02535   if (!ptr)
02536     return SWIG_Py_Void();
02537 
02538   clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
02539   own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
02540   if (clientdata && clientdata->pytype) {
02541     SwigPyObject *newobj;
02542     if (flags & SWIG_BUILTIN_TP_INIT) {
02543       newobj = (SwigPyObject*) self;
02544       if (newobj->ptr) {
02545         PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
02546         while (newobj->next)
02547           newobj = (SwigPyObject *) newobj->next;
02548         newobj->next = next_self;
02549         newobj = (SwigPyObject *)next_self;
02550       }
02551     } else {
02552       newobj = PyObject_New(SwigPyObject, clientdata->pytype);
02553     }
02554     if (newobj) {
02555       newobj->ptr = ptr;
02556       newobj->ty = type;
02557       newobj->own = own;
02558       newobj->next = 0;
02559 #ifdef SWIGPYTHON_BUILTIN
02560       newobj->dict = 0;
02561 #endif
02562       return (PyObject*) newobj;
02563     }
02564     return SWIG_Py_Void();
02565   }
02566 
02567   assert(!(flags & SWIG_BUILTIN_TP_INIT));
02568 
02569   robj = SwigPyObject_New(ptr, type, own);
02570   if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
02571     PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
02572     Py_DECREF(robj);
02573     robj = inst;
02574   }
02575   return robj;
02576 }
02577 
02578 /* Create a new packed object */
02579 
02580 SWIGRUNTIMEINLINE PyObject *
02581 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
02582   return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
02583 }
02584 
02585 /* -----------------------------------------------------------------------------*
02586  *  Get type list 
02587  * -----------------------------------------------------------------------------*/
02588 
02589 #ifdef SWIG_LINK_RUNTIME
02590 void *SWIG_ReturnGlobalTypeList(void *);
02591 #endif
02592 
02593 SWIGRUNTIME swig_module_info *
02594 SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
02595   static void *type_pointer = (void *)0;
02596   /* first check if module already created */
02597   if (!type_pointer) {
02598 #ifdef SWIG_LINK_RUNTIME
02599     type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
02600 #else
02601 # ifdef SWIGPY_USE_CAPSULE
02602     type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
02603 # else
02604     type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
02605                                     (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
02606 # endif
02607     if (PyErr_Occurred()) {
02608       PyErr_Clear();
02609       type_pointer = (void *)0;
02610     }
02611 #endif
02612   }
02613   return (swig_module_info *) type_pointer;
02614 }
02615 
02616 #if PY_MAJOR_VERSION < 2
02617 /* PyModule_AddObject function was introduced in Python 2.0.  The following function
02618    is copied out of Python/modsupport.c in python version 2.3.4 */
02619 SWIGINTERN int
02620 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
02621 {
02622   PyObject *dict;
02623   if (!PyModule_Check(m)) {
02624     PyErr_SetString(PyExc_TypeError,
02625                     "PyModule_AddObject() needs module as first arg");
02626     return SWIG_ERROR;
02627   }
02628   if (!o) {
02629     PyErr_SetString(PyExc_TypeError,
02630                     "PyModule_AddObject() needs non-NULL value");
02631     return SWIG_ERROR;
02632   }
02633   
02634   dict = PyModule_GetDict(m);
02635   if (dict == NULL) {
02636     /* Internal error -- modules must have a dict! */
02637     PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
02638                  PyModule_GetName(m));
02639     return SWIG_ERROR;
02640   }
02641   if (PyDict_SetItemString(dict, name, o))
02642     return SWIG_ERROR;
02643   Py_DECREF(o);
02644   return SWIG_OK;
02645 }
02646 #endif
02647 
02648 SWIGRUNTIME void
02649 #ifdef SWIGPY_USE_CAPSULE
02650 SWIG_Python_DestroyModule(PyObject *obj)
02651 #else
02652 SWIG_Python_DestroyModule(void *vptr)
02653 #endif
02654 {
02655 #ifdef SWIGPY_USE_CAPSULE
02656   swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
02657 #else
02658   swig_module_info *swig_module = (swig_module_info *) vptr;
02659 #endif
02660   swig_type_info **types = swig_module->types;
02661   size_t i;
02662   for (i =0; i < swig_module->size; ++i) {
02663     swig_type_info *ty = types[i];
02664     if (ty->owndata) {
02665       SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
02666       if (data) SwigPyClientData_Del(data);
02667     }
02668   }
02669   Py_DECREF(SWIG_This());
02670   swig_this = NULL;
02671 }
02672 
02673 SWIGRUNTIME void
02674 SWIG_Python_SetModule(swig_module_info *swig_module) {
02675 #if PY_VERSION_HEX >= 0x03000000
02676  /* Add a dummy module object into sys.modules */
02677   PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
02678 #else
02679   static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
02680   PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
02681 #endif
02682 #ifdef SWIGPY_USE_CAPSULE
02683   PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
02684   if (pointer && module) {
02685     PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
02686   } else {
02687     Py_XDECREF(pointer);
02688   }
02689 #else
02690   PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
02691   if (pointer && module) {
02692     PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
02693   } else {
02694     Py_XDECREF(pointer);
02695   }
02696 #endif
02697 }
02698 
02699 /* The python cached type query */
02700 SWIGRUNTIME PyObject *
02701 SWIG_Python_TypeCache(void) {
02702   static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
02703   return cache;
02704 }
02705 
02706 SWIGRUNTIME swig_type_info *
02707 SWIG_Python_TypeQuery(const char *type)
02708 {
02709   PyObject *cache = SWIG_Python_TypeCache();
02710   PyObject *key = SWIG_Python_str_FromChar(type); 
02711   PyObject *obj = PyDict_GetItem(cache, key);
02712   swig_type_info *descriptor;
02713   if (obj) {
02714 #ifdef SWIGPY_USE_CAPSULE
02715     descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
02716 #else
02717     descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
02718 #endif
02719   } else {
02720     swig_module_info *swig_module = SWIG_GetModule(0);
02721     descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
02722     if (descriptor) {
02723 #ifdef SWIGPY_USE_CAPSULE
02724       obj = PyCapsule_New((void*) descriptor, NULL, NULL);
02725 #else
02726       obj = PyCObject_FromVoidPtr(descriptor, NULL);
02727 #endif
02728       PyDict_SetItem(cache, key, obj);
02729       Py_DECREF(obj);
02730     }
02731   }
02732   Py_DECREF(key);
02733   return descriptor;
02734 }
02735 
02736 /* 
02737    For backward compatibility only
02738 */
02739 #define SWIG_POINTER_EXCEPTION  0
02740 #define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
02741 #define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
02742 
02743 SWIGRUNTIME int
02744 SWIG_Python_AddErrMesg(const char* mesg, int infront)
02745 {  
02746   if (PyErr_Occurred()) {
02747     PyObject *type = 0;
02748     PyObject *value = 0;
02749     PyObject *traceback = 0;
02750     PyErr_Fetch(&type, &value, &traceback);
02751     if (value) {
02752       char *tmp;
02753       PyObject *old_str = PyObject_Str(value);
02754       Py_XINCREF(type);
02755       PyErr_Clear();
02756       if (infront) {
02757         PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
02758       } else {
02759         PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
02760       }
02761       SWIG_Python_str_DelForPy3(tmp);
02762       Py_DECREF(old_str);
02763     }
02764     return 1;
02765   } else {
02766     return 0;
02767   }
02768 }
02769   
02770 SWIGRUNTIME int
02771 SWIG_Python_ArgFail(int argnum)
02772 {
02773   if (PyErr_Occurred()) {
02774     /* add information about failing argument */
02775     char mesg[256];
02776     PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
02777     return SWIG_Python_AddErrMesg(mesg, 1);
02778   } else {
02779     return 0;
02780   }
02781 }
02782 
02783 SWIGRUNTIMEINLINE const char *
02784 SwigPyObject_GetDesc(PyObject *self)
02785 {
02786   SwigPyObject *v = (SwigPyObject *)self;
02787   swig_type_info *ty = v ? v->ty : 0;
02788   return ty ? ty->str : "";
02789 }
02790 
02791 SWIGRUNTIME void
02792 SWIG_Python_TypeError(const char *type, PyObject *obj)
02793 {
02794   if (type) {
02795 #if defined(SWIG_COBJECT_TYPES)
02796     if (obj && SwigPyObject_Check(obj)) {
02797       const char *otype = (const char *) SwigPyObject_GetDesc(obj);
02798       if (otype) {
02799         PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
02800                      type, otype);
02801         return;
02802       }
02803     } else 
02804 #endif      
02805     {
02806       const char *otype = (obj ? obj->ob_type->tp_name : 0); 
02807       if (otype) {
02808         PyObject *str = PyObject_Str(obj);
02809         const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
02810         if (cstr) {
02811           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
02812                        type, otype, cstr);
02813           SWIG_Python_str_DelForPy3(cstr);
02814         } else {
02815           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
02816                        type, otype);
02817         }
02818         Py_XDECREF(str);
02819         return;
02820       }
02821     }   
02822     PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
02823   } else {
02824     PyErr_Format(PyExc_TypeError, "unexpected type is received");
02825   }
02826 }
02827 
02828 
02829 /* Convert a pointer value, signal an exception on a type mismatch */
02830 SWIGRUNTIME void *
02831 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
02832   void *result;
02833   if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
02834     PyErr_Clear();
02835 #if SWIG_POINTER_EXCEPTION
02836     if (flags) {
02837       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
02838       SWIG_Python_ArgFail(argnum);
02839     }
02840 #endif
02841   }
02842   return result;
02843 }
02844 
02845 #ifdef SWIGPYTHON_BUILTIN
02846 SWIGRUNTIME int
02847 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
02848   PyTypeObject *tp = obj->ob_type;
02849   PyObject *descr;
02850   PyObject *encoded_name;
02851   descrsetfunc f;
02852   int res = -1;
02853 
02854 # ifdef Py_USING_UNICODE
02855   if (PyString_Check(name)) {
02856     name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
02857     if (!name)
02858       return -1;
02859   } else if (!PyUnicode_Check(name))
02860 # else
02861   if (!PyString_Check(name))
02862 # endif
02863   {
02864     PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
02865     return -1;
02866   } else {
02867     Py_INCREF(name);
02868   }
02869 
02870   if (!tp->tp_dict) {
02871     if (PyType_Ready(tp) < 0)
02872       goto done;
02873   }
02874 
02875   descr = _PyType_Lookup(tp, name);
02876   f = NULL;
02877   if (descr != NULL)
02878     f = descr->ob_type->tp_descr_set;
02879   if (!f) {
02880     if (PyString_Check(name)) {
02881       encoded_name = name;
02882       Py_INCREF(name);
02883     } else {
02884       encoded_name = PyUnicode_AsUTF8String(name);
02885     }
02886     PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
02887     Py_DECREF(encoded_name);
02888   } else {
02889     res = f(descr, obj, value);
02890   }
02891   
02892   done:
02893   Py_DECREF(name);
02894   return res;
02895 }
02896 #endif
02897 
02898 
02899 #ifdef __cplusplus
02900 }
02901 #endif
02902 
02903 
02904 
02905 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
02906 
02907 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
02908 
02909 
02910 
02911 /* -------- TYPES TABLE (BEGIN) -------- */
02912 
02913 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
02914 #define SWIGTYPE_p_PLcGrid swig_types[1]
02915 #define SWIGTYPE_p_PLcGrid2 swig_types[2]
02916 #define SWIGTYPE_p_char swig_types[3]
02917 #define SWIGTYPE_p_double swig_types[4]
02918 #define SWIGTYPE_p_f_double_double__int swig_types[5]
02919 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
02920 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
02921 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
02922 #define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
02923 #define SWIGTYPE_p_int swig_types[10]
02924 #define SWIGTYPE_p_p_char swig_types[11]
02925 #define SWIGTYPE_p_p_double swig_types[12]
02926 #define SWIGTYPE_p_unsigned_int swig_types[13]
02927 static swig_type_info *swig_types[15];
02928 static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
02929 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
02930 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
02931 
02932 /* -------- TYPES TABLE (END) -------- */
02933 
02934 #if (PY_VERSION_HEX <= 0x02000000)
02935 # if !defined(SWIG_PYTHON_CLASSIC)
02936 #  error "This python version requires swig to be run with the '-classic' option"
02937 # endif
02938 #endif
02939 
02940 /*-----------------------------------------------
02941               @(target):= _plplotc.so
02942   ------------------------------------------------*/
02943 #if PY_VERSION_HEX >= 0x03000000
02944 #  define SWIG_init    PyInit__plplotc
02945 
02946 #else
02947 #  define SWIG_init    init_plplotc
02948 
02949 #endif
02950 #define SWIG_name    "_plplotc"
02951 
02952 #define SWIGVERSION 0x030002 
02953 #define SWIG_VERSION SWIGVERSION
02954 
02955 
02956 #define SWIG_as_voidptr(a) (void *)((const void *)(a)) 
02957 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a)) 
02958 
02959 
02960 // define NPY_NO_DEPRECATED_API    NPY_1_7_API_VERSION
02961 #include <numpy/arrayobject.h>
02962 #include "plplot.h"
02963 #include "plplotP.h"
02964 
02965 #define  NPY_PLINT    NPY_INT32
02966 
02967 #ifdef PL_DOUBLE
02968 #define  NPY_PLFLT    NPY_FLOAT64
02969 #else
02970 #define  NPY_PLFLT    NPY_FLOAT32
02971 #endif
02972 
02973 // python-1.5 compatibility mode?
02974 #if !defined ( PySequence_Fast_GET_ITEM )
02975   #define PySequence_Fast_GET_ITEM    PySequence_GetItem
02976 #endif
02977 #define PySequence_Size               PySequence_Length
02978 
02979 
02980     static PLINT Alen = 0;
02981     static PLINT Xlen = 0, Ylen = 0;
02982 
02983 
02984 SWIGINTERN int
02985 SWIG_AsVal_double (PyObject *obj, double *val)
02986 {
02987   int res = SWIG_TypeError;
02988   if (PyFloat_Check(obj)) {
02989     if (val) *val = PyFloat_AsDouble(obj);
02990     return SWIG_OK;
02991   } else if (PyInt_Check(obj)) {
02992     if (val) *val = PyInt_AsLong(obj);
02993     return SWIG_OK;
02994   } else if (PyLong_Check(obj)) {
02995     double v = PyLong_AsDouble(obj);
02996     if (!PyErr_Occurred()) {
02997       if (val) *val = v;
02998       return SWIG_OK;
02999     } else {
03000       PyErr_Clear();
03001     }
03002   }
03003 #ifdef SWIG_PYTHON_CAST_MODE
03004   {
03005     int dispatch = 0;
03006     double d = PyFloat_AsDouble(obj);
03007     if (!PyErr_Occurred()) {
03008       if (val) *val = d;
03009       return SWIG_AddCast(SWIG_OK);
03010     } else {
03011       PyErr_Clear();
03012     }
03013     if (!dispatch) {
03014       long v = PyLong_AsLong(obj);
03015       if (!PyErr_Occurred()) {
03016         if (val) *val = v;
03017         return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
03018       } else {
03019         PyErr_Clear();
03020       }
03021     }
03022   }
03023 #endif
03024   return res;
03025 }
03026 
03027 
03028   #define SWIG_From_double   PyFloat_FromDouble 
03029 
03030 
03031     typedef PLINT ( *defined_func )( PLFLT, PLFLT );
03032     typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
03033     typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
03034     typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
03035     typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
03036     typedef PLFLT ( *f2eval_func )( PLINT, PLINT, PLPointer );
03037     typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
03038 
03039 
03040 SWIGINTERNINLINE PyObject*
03041   SWIG_From_int  (int value)
03042 {
03043   return PyInt_FromLong((long) value);
03044 }
03045 
03046 
03047 #include <limits.h>
03048 #if !defined(SWIG_NO_LLONG_MAX)
03049 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
03050 #   define LLONG_MAX __LONG_LONG_MAX__
03051 #   define LLONG_MIN (-LLONG_MAX - 1LL)
03052 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
03053 # endif
03054 #endif
03055 
03056 
03057 #include <float.h>
03058 
03059 
03060 #include <math.h>
03061 
03062 
03063 SWIGINTERNINLINE int
03064 SWIG_CanCastAsInteger(double *d, double min, double max) {
03065   double x = *d;
03066   if ((min <= x && x <= max)) {
03067    double fx = floor(x);
03068    double cx = ceil(x);
03069    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
03070    if ((errno == EDOM) || (errno == ERANGE)) {
03071      errno = 0;
03072    } else {
03073      double summ, reps, diff;
03074      if (rd < x) {
03075        diff = x - rd;
03076      } else if (rd > x) {
03077        diff = rd - x;
03078      } else {
03079        return 1;
03080      }
03081      summ = rd + x;
03082      reps = diff/summ;
03083      if (reps < 8*DBL_EPSILON) {
03084        *d = rd;
03085        return 1;
03086      }
03087    }
03088   }
03089   return 0;
03090 }
03091 
03092 
03093 SWIGINTERN int
03094 SWIG_AsVal_long (PyObject *obj, long* val)
03095 {
03096   if (PyInt_Check(obj)) {
03097     if (val) *val = PyInt_AsLong(obj);
03098     return SWIG_OK;
03099   } else if (PyLong_Check(obj)) {
03100     long v = PyLong_AsLong(obj);
03101     if (!PyErr_Occurred()) {
03102       if (val) *val = v;
03103       return SWIG_OK;
03104     } else {
03105       PyErr_Clear();
03106     }
03107   }
03108 #ifdef SWIG_PYTHON_CAST_MODE
03109   {
03110     int dispatch = 0;
03111     long v = PyInt_AsLong(obj);
03112     if (!PyErr_Occurred()) {
03113       if (val) *val = v;
03114       return SWIG_AddCast(SWIG_OK);
03115     } else {
03116       PyErr_Clear();
03117     }
03118     if (!dispatch) {
03119       double d;
03120       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
03121       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
03122         if (val) *val = (long)(d);
03123         return res;
03124       }
03125     }
03126   }
03127 #endif
03128   return SWIG_TypeError;
03129 }
03130 
03131 
03132 SWIGINTERN int
03133 SWIG_AsVal_int (PyObject * obj, int *val)
03134 {
03135   long v;
03136   int res = SWIG_AsVal_long (obj, &v);
03137   if (SWIG_IsOK(res)) {
03138     if ((v < INT_MIN || v > INT_MAX)) {
03139       return SWIG_OverflowError;
03140     } else {
03141       if (val) *val = (int)(v);
03142     }
03143   }  
03144   return res;
03145 }
03146 
03147 
03148 SWIGINTERN int
03149 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
03150 {
03151 #if PY_VERSION_HEX < 0x03000000
03152   if (PyInt_Check(obj)) {
03153     long v = PyInt_AsLong(obj);
03154     if (v >= 0) {
03155       if (val) *val = v;
03156       return SWIG_OK;
03157     } else {
03158       return SWIG_OverflowError;
03159     }
03160   } else
03161 #endif
03162   if (PyLong_Check(obj)) {
03163     unsigned long v = PyLong_AsUnsignedLong(obj);
03164     if (!PyErr_Occurred()) {
03165       if (val) *val = v;
03166       return SWIG_OK;
03167     } else {
03168       PyErr_Clear();
03169 #if PY_VERSION_HEX >= 0x03000000
03170       {
03171         long v = PyLong_AsLong(obj);
03172         if (!PyErr_Occurred()) {
03173           if (v < 0) {
03174             return SWIG_OverflowError;
03175           }
03176         } else {
03177           PyErr_Clear();
03178         }
03179       }
03180 #endif
03181     }
03182   }
03183 #ifdef SWIG_PYTHON_CAST_MODE
03184   {
03185     int dispatch = 0;
03186     unsigned long v = PyLong_AsUnsignedLong(obj);
03187     if (!PyErr_Occurred()) {
03188       if (val) *val = v;
03189       return SWIG_AddCast(SWIG_OK);
03190     } else {
03191       PyErr_Clear();
03192     }
03193     if (!dispatch) {
03194       double d;
03195       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
03196       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
03197         if (val) *val = (unsigned long)(d);
03198         return res;
03199       }
03200     }
03201   }
03202 #endif
03203   return SWIG_TypeError;
03204 }
03205 
03206 
03207 SWIGINTERN int
03208 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
03209 {
03210   unsigned long v;
03211   int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
03212   if (SWIG_IsOK(res)) {
03213     if ((v > UINT_MAX)) {
03214       return SWIG_OverflowError;
03215     } else {
03216       if (val) *val = (unsigned int)(v);
03217     }
03218   }  
03219   return res;
03220 }
03221 
03222 
03223 SWIGINTERNINLINE PyObject*
03224   SWIG_From_unsigned_SS_int  (unsigned int value)
03225 {
03226   return PyInt_FromSize_t((size_t) value);
03227 }
03228 
03229 
03230 SWIGINTERN swig_type_info*
03231 SWIG_pchar_descriptor(void)
03232 {
03233   static int init = 0;
03234   static swig_type_info* info = 0;
03235   if (!init) {
03236     info = SWIG_TypeQuery("_p_char");
03237     init = 1;
03238   }
03239   return info;
03240 }
03241 
03242 
03243 SWIGINTERN int
03244 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
03245 {
03246 #if PY_VERSION_HEX>=0x03000000
03247   if (PyUnicode_Check(obj))
03248 #else  
03249   if (PyString_Check(obj))
03250 #endif
03251   {
03252     char *cstr; Py_ssize_t len;
03253 #if PY_VERSION_HEX>=0x03000000
03254     if (!alloc && cptr) {
03255         /* We can't allow converting without allocation, since the internal
03256            representation of string in Python 3 is UCS-2/UCS-4 but we require
03257            a UTF-8 representation.
03258            TODO(bhy) More detailed explanation */
03259         return SWIG_RuntimeError;
03260     }
03261     obj = PyUnicode_AsUTF8String(obj);
03262     PyBytes_AsStringAndSize(obj, &cstr, &len);
03263     if(alloc) *alloc = SWIG_NEWOBJ;
03264 #else
03265     PyString_AsStringAndSize(obj, &cstr, &len);
03266 #endif
03267     if (cptr) {
03268       if (alloc) {
03269         /* 
03270            In python the user should not be able to modify the inner
03271            string representation. To warranty that, if you define
03272            SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
03273            buffer is always returned.
03274 
03275            The default behavior is just to return the pointer value,
03276            so, be careful.
03277         */ 
03278 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
03279         if (*alloc != SWIG_OLDOBJ) 
03280 #else
03281         if (*alloc == SWIG_NEWOBJ) 
03282 #endif
03283           {
03284             *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
03285             *alloc = SWIG_NEWOBJ;
03286           }
03287         else {
03288           *cptr = cstr;
03289           *alloc = SWIG_OLDOBJ;
03290         }
03291       } else {
03292         #if PY_VERSION_HEX>=0x03000000
03293         assert(0); /* Should never reach here in Python 3 */
03294         #endif
03295         *cptr = SWIG_Python_str_AsChar(obj);
03296       }
03297     }
03298     if (psize) *psize = len + 1;
03299 #if PY_VERSION_HEX>=0x03000000
03300     Py_XDECREF(obj);
03301 #endif
03302     return SWIG_OK;
03303   } else {
03304     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
03305     if (pchar_descriptor) {
03306       void* vptr = 0;
03307       if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
03308         if (cptr) *cptr = (char *) vptr;
03309         if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
03310         if (alloc) *alloc = SWIG_OLDOBJ;
03311         return SWIG_OK;
03312       }
03313     }
03314   }
03315   return SWIG_TypeError;
03316 }
03317 
03318 
03319 SWIGINTERN int
03320 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
03321 { 
03322   char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
03323   int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
03324   if (SWIG_IsOK(res)) {
03325     /* special case of single char conversion when we don't need space for NUL */
03326     if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
03327     if (csize <= size) {
03328       if (val) {
03329         if (csize) memcpy(val, cptr, csize*sizeof(char));
03330         if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
03331       }
03332       if (alloc == SWIG_NEWOBJ) {
03333         free((char*)cptr);
03334         res = SWIG_DelNewMask(res);
03335       }      
03336       return res;
03337     }
03338     if (alloc == SWIG_NEWOBJ) free((char*)cptr);
03339   }
03340   return SWIG_TypeError;
03341 }
03342 
03343 
03344 SWIGINTERNINLINE PyObject *
03345 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
03346 {
03347   if (carray) {
03348     if (size > INT_MAX) {
03349       swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
03350       return pchar_descriptor ? 
03351         SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
03352     } else {
03353 #if PY_VERSION_HEX >= 0x03000000
03354 #if PY_VERSION_HEX >= 0x03010000
03355       return PyUnicode_DecodeUTF8(carray, (int)(size), "surrogateescape");
03356 #else
03357       return PyUnicode_FromStringAndSize(carray, (int)(size));
03358 #endif
03359 #else
03360       return PyString_FromStringAndSize(carray, (int)(size));
03361 #endif
03362     }
03363   } else {
03364     return SWIG_Py_Void();
03365   }
03366 }
03367 
03368 
03369 size_t
03370 SWIG_strnlen(const char* s, size_t maxlen)
03371 {
03372   const char *p;
03373   for (p = s; maxlen-- && *p; p++)
03374     ;
03375   return p - s;
03376 }
03377 
03378 
03379 
03380 
03381 
03382 #define t_output_helper SWIG_Python_AppendOutput
03383 
03384 
03385 SWIGINTERN int
03386 SWIG_AsVal_char (PyObject * obj, char *val)
03387 {    
03388   int res = SWIG_AsCharArray(obj, val, 1);
03389   if (!SWIG_IsOK(res)) {
03390     long v;
03391     res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
03392     if (SWIG_IsOK(res)) {
03393       if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
03394         if (val) *val = (char)(v);
03395       } else {
03396         res = SWIG_OverflowError;
03397       }
03398     }
03399   }
03400   return res;
03401 }
03402 
03403 #ifdef __cplusplus
03404 extern "C" {
03405 #endif
03406 
03407     PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims );
03408 
03409 // some really twisted stuff to allow calling a single precision library from python
03410     PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int PL_UNUSED( type ), int mindims, int maxdims )
03411     {
03412         PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, NPY_PLINT,
03413             mindims, maxdims );
03414         if ( !tmp )
03415         {
03416             // could be an incoming long array which can't be "safely" converted, do it anyway
03417             if ( PyArray_Check( in ) )
03418             {
03419                 PyErr_Clear();
03420                 tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, NPY_PLINT );
03421             }
03422         }
03423         return tmp;
03424     }
03425 
03426 
03427 #define myArray_ContiguousFromObject    PyArray_ContiguousFromObject
03428 
03429 SWIGINTERN PyObject *_wrap_pltr0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03430   PyObject *resultobj = 0;
03431   PLFLT arg1 ;
03432   PLFLT arg2 ;
03433   PLFLT *arg3 = (PLFLT *) 0 ;
03434   PLFLT *arg4 = (PLFLT *) 0 ;
03435   PLPointer arg5 = (PLPointer) 0 ;
03436   double val1 ;
03437   int ecode1 = 0 ;
03438   double val2 ;
03439   int ecode2 = 0 ;
03440   PLFLT temp3 ;
03441   int res3 = SWIG_TMPOBJ ;
03442   PLFLT temp4 ;
03443   int res4 = SWIG_TMPOBJ ;
03444   PyObject * obj0 = 0 ;
03445   PyObject * obj1 = 0 ;
03446   
03447   arg3 = &temp3;
03448   arg4 = &temp4;
03449   {
03450     arg5 = NULL;
03451   }
03452   if (!PyArg_ParseTuple(args,(char *)"OO:pltr0",&obj0,&obj1)) SWIG_fail;
03453   ecode1 = SWIG_AsVal_double(obj0, &val1);
03454   if (!SWIG_IsOK(ecode1)) {
03455     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'");
03456   } 
03457   arg1 = (PLFLT)(val1);
03458   ecode2 = SWIG_AsVal_double(obj1, &val2);
03459   if (!SWIG_IsOK(ecode2)) {
03460     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'");
03461   } 
03462   arg2 = (PLFLT)(val2);
03463   pltr0(arg1,arg2,arg3,arg4,arg5);
03464   resultobj = SWIG_Py_Void();
03465   if (SWIG_IsTmpObj(res3)) {
03466     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
03467   } else {
03468     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
03469     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
03470   }
03471   if (SWIG_IsTmpObj(res4)) {
03472     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
03473   } else {
03474     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
03475     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
03476   }
03477   return resultobj;
03478 fail:
03479   return NULL;
03480 }
03481 
03482 
03483 
03484     PyArrayObject   *pltr_xg, *pltr_yg;
03485     static PLcGrid  tmpGrid1;
03486     static PLcGrid2 tmpGrid2;
03487 
03488     PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg );
03489     void cleanup_PLcGrid1( void );
03490     PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg );
03491     void cleanup_PLcGrid2( void );
03492 
03493     PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg )
03494     {
03495         // fprintf(stderr, "marshal PLcGrid1\n");
03496         if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
03497         {
03498             PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
03499             return NULL;
03500         }
03501         pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
03502             NPY_PLFLT, 1, 1 );
03503         pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
03504             NPY_PLFLT, 1, 1 );
03505         if ( pltr_xg == 0 || pltr_yg == 0 )
03506         {
03507             PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." );
03508             return NULL;
03509         }
03510         tmpGrid1.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
03511         tmpGrid1.ny = (PLINT) PyArray_DIMS( pltr_yg )[0];
03512         if ( isimg == 0 )
03513         {
03514             if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny )
03515             {
03516                 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
03517                 return NULL;
03518             }
03519         }
03520         else
03521         {
03522             if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 )
03523             {
03524                 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
03525                 return NULL;
03526             }
03527         }
03528         tmpGrid1.xg = (PLFLT *) PyArray_DATA( pltr_xg );
03529         tmpGrid1.yg = (PLFLT *) PyArray_DATA( pltr_yg );
03530         return &tmpGrid1;
03531     }
03532 
03533     void cleanup_PLcGrid1( void )
03534     {
03535         // fprintf(stderr, "cleanup PLcGrid1\n");
03536         Py_CLEAR( pltr_xg );
03537         Py_CLEAR( pltr_yg );
03538     }
03539 
03540     PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg )
03541     {
03542         int i, size;
03543         // fprintf(stderr, "marshal PLcGrid2\n");
03544         if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
03545         {
03546             PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
03547             return NULL;
03548         }
03549         pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
03550             NPY_PLFLT, 2, 2 );
03551         pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
03552             NPY_PLFLT, 2, 2 );
03553         if ( pltr_xg == 0 || pltr_yg == 0 )
03554         {
03555             PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." );
03556             return NULL;
03557         }
03558         if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
03559              PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
03560         {
03561             PyErr_SetString( PyExc_ValueError, "Arrays must be same size." );
03562             return NULL;
03563         }
03564         tmpGrid2.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
03565         tmpGrid2.ny = (PLINT) PyArray_DIMS( pltr_xg )[1];
03566         if ( isimg == 0 )
03567         {
03568             if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny )
03569             {
03570                 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
03571                 return NULL;
03572             }
03573         }
03574         else
03575         {
03576             if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 )
03577             {
03578                 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
03579                 return NULL;
03580             }
03581         }
03582         size        = tmpGrid2.ny;
03583         tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
03584         for ( i = 0; i < tmpGrid2.nx; i++ )
03585             tmpGrid2.xg[i] = ( (PLFLT *) PyArray_DATA( pltr_xg ) + i * size );
03586         tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
03587         for ( i = 0; i < tmpGrid2.nx; i++ )
03588             tmpGrid2.yg[i] = ( (PLFLT *) PyArray_DATA( pltr_yg ) + i * size );
03589         return &tmpGrid2;
03590     }
03591 
03592     void cleanup_PLcGrid2( void )
03593     {
03594         // fprintf(stderr, "cleanup PLcGrid2\n");
03595         free( tmpGrid2.xg );
03596         free( tmpGrid2.yg );
03597         Py_CLEAR( pltr_xg );
03598         Py_CLEAR( pltr_yg );
03599     }
03600 
03601 SWIGINTERN PyObject *_wrap_pltr1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03602   PyObject *resultobj = 0;
03603   PLFLT arg1 ;
03604   PLFLT arg2 ;
03605   PLFLT *arg3 = (PLFLT *) 0 ;
03606   PLFLT *arg4 = (PLFLT *) 0 ;
03607   PLcGrid *arg5 = (PLcGrid *) 0 ;
03608   double val1 ;
03609   int ecode1 = 0 ;
03610   double val2 ;
03611   int ecode2 = 0 ;
03612   PLFLT temp3 ;
03613   int res3 = SWIG_TMPOBJ ;
03614   PLFLT temp4 ;
03615   int res4 = SWIG_TMPOBJ ;
03616   PyObject * obj0 = 0 ;
03617   PyObject * obj1 = 0 ;
03618   PyObject * obj2 = 0 ;
03619   
03620   arg3 = &temp3;
03621   arg4 = &temp4;
03622   if (!PyArg_ParseTuple(args,(char *)"OOO:pltr1",&obj0,&obj1,&obj2)) SWIG_fail;
03623   ecode1 = SWIG_AsVal_double(obj0, &val1);
03624   if (!SWIG_IsOK(ecode1)) {
03625     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'");
03626   } 
03627   arg1 = (PLFLT)(val1);
03628   ecode2 = SWIG_AsVal_double(obj1, &val2);
03629   if (!SWIG_IsOK(ecode2)) {
03630     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'");
03631   } 
03632   arg2 = (PLFLT)(val2);
03633   {
03634     arg5 = marshal_PLcGrid1( obj2, 0 );
03635     if ( !arg5 )
03636     return NULL;
03637   }
03638   pltr1(arg1,arg2,arg3,arg4,arg5);
03639   resultobj = SWIG_Py_Void();
03640   if (SWIG_IsTmpObj(res3)) {
03641     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
03642   } else {
03643     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
03644     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
03645   }
03646   if (SWIG_IsTmpObj(res4)) {
03647     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
03648   } else {
03649     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
03650     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
03651   }
03652   {
03653     cleanup_PLcGrid1();
03654   }
03655   return resultobj;
03656 fail:
03657   {
03658     cleanup_PLcGrid1();
03659   }
03660   return NULL;
03661 }
03662 
03663 
03664 SWIGINTERN PyObject *_wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03665   PyObject *resultobj = 0;
03666   PLFLT arg1 ;
03667   PLFLT arg2 ;
03668   PLFLT *arg3 = (PLFLT *) 0 ;
03669   PLFLT *arg4 = (PLFLT *) 0 ;
03670   PLcGrid2 *arg5 = (PLcGrid2 *) 0 ;
03671   double val1 ;
03672   int ecode1 = 0 ;
03673   double val2 ;
03674   int ecode2 = 0 ;
03675   PLFLT temp3 ;
03676   int res3 = SWIG_TMPOBJ ;
03677   PLFLT temp4 ;
03678   int res4 = SWIG_TMPOBJ ;
03679   PyObject * obj0 = 0 ;
03680   PyObject * obj1 = 0 ;
03681   PyObject * obj2 = 0 ;
03682   
03683   arg3 = &temp3;
03684   arg4 = &temp4;
03685   if (!PyArg_ParseTuple(args,(char *)"OOO:pltr2",&obj0,&obj1,&obj2)) SWIG_fail;
03686   ecode1 = SWIG_AsVal_double(obj0, &val1);
03687   if (!SWIG_IsOK(ecode1)) {
03688     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'");
03689   } 
03690   arg1 = (PLFLT)(val1);
03691   ecode2 = SWIG_AsVal_double(obj1, &val2);
03692   if (!SWIG_IsOK(ecode2)) {
03693     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'");
03694   } 
03695   arg2 = (PLFLT)(val2);
03696   {
03697     arg5 = marshal_PLcGrid2( obj2, 0 );
03698     if ( !arg5 )
03699     return NULL;
03700   }
03701   pltr2(arg1,arg2,arg3,arg4,arg5);
03702   resultobj = SWIG_Py_Void();
03703   if (SWIG_IsTmpObj(res3)) {
03704     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
03705   } else {
03706     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
03707     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
03708   }
03709   if (SWIG_IsTmpObj(res4)) {
03710     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
03711   } else {
03712     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
03713     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
03714   }
03715   {
03716     cleanup_PLcGrid2();
03717   }
03718   return resultobj;
03719 fail:
03720   {
03721     cleanup_PLcGrid2();
03722   }
03723   return NULL;
03724 }
03725 
03726 
03727 
03728     // helper code for handling the callback
03729 #if 0
03730     static PyInterpreterState *save_interp = NULL;
03731 #endif
03732     enum callback_type { CB_0, CB_1, CB_2, CB_Python } pltr_type;
03733     PyObject* python_pltr    = NULL;
03734     PyObject* python_f2eval  = NULL;
03735     PyObject* python_ct      = NULL;
03736     PyObject* python_mapform = NULL;
03737     PyObject* python_label   = NULL;
03738 
03739 #if 0
03740 #define MY_BLOCK_THREADS    {                             \
03741         PyThreadState *prev_state, *new_state;            \
03742         /* need to have started a thread at some stage */ \
03743         /* for the following to work */                   \
03744         PyEval_AcquireLock();                             \
03745         new_state  = PyThreadState_New( save_interp );    \
03746         prev_state = PyThreadState_Swap( new_state );
03747 #define MY_UNBLOCK_THREADS                        \
03748     new_state = PyThreadState_Swap( prev_state ); \
03749     PyThreadState_Clear( new_state );             \
03750     PyEval_ReleaseLock();                         \
03751     PyThreadState_Delete( new_state );            \
03752     }
03753 #else
03754 #define MY_BLOCK_THREADS
03755 #define MY_UNBLOCK_THREADS
03756 #endif
03757 
03758 // Function prototypes
03759     void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data );
03760     PLFLT do_f2eval_callback( PLINT x, PLINT y, PLPointer data );
03761     void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data );
03762     void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data );
03763     void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y );
03764     pltr_func marshal_pltr( PyObject* input );
03765     void cleanup_pltr( void );
03766     ct_func marshal_ct( PyObject* input );
03767     void cleanup_ct( void );
03768     mapform_func marshal_mapform( PyObject* input );
03769     void cleanup_mapform( void );
03770     PLPointer marshal_PLPointer( PyObject* input, int isimg );
03771     void cleanup_PLPointer( void );
03772 
03773 
03774 // This is the callback that gets handed to the C code. It, in turn, calls the Python callback
03775 
03776     void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data )
03777     {
03778         PyObject      *pdata, *arglist, *result;
03779         PyArrayObject *tmp;
03780 
03781         // the data argument is acutally a pointer to a python object
03782         pdata = (PyObject *) data;
03783         if ( data == NULL )
03784         {
03785             pdata = Py_None;
03786         }
03787         if ( python_pltr ) // if not something is terribly wrong
03788         {                  // hold a reference to the data object
03789             Py_XINCREF( pdata );
03790             // grab the Global Interpreter Lock to be sure threads don't mess us up
03791             MY_BLOCK_THREADS
03792             // build the argument list
03793 #ifdef PL_DOUBLE
03794             arglist = Py_BuildValue( "(ddO)", x, y, pdata );
03795 #else
03796             arglist = Py_BuildValue( "(ffO)", x, y, pdata );
03797 #endif
03798             if ( arglist == NULL )
03799             {
03800                 fprintf( stderr, "Py_BuildValue failed to make argument list.\n" );
03801                 *tx = *ty = 0;
03802                 return;
03803             }
03804             // call the python function
03805             result = PyEval_CallObject( python_pltr, arglist );
03806             // release the argument list
03807             Py_CLEAR( arglist );
03808             // check and unpack the result
03809             if ( result == NULL )
03810             {
03811                 fprintf( stderr, "call to python pltr function with 3 arguments failed\n" );
03812                 PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 argments." );
03813                 *tx = *ty = 0;
03814             }
03815             else
03816             {
03817                 tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, NPY_PLFLT, 1, 1 );
03818                 if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
03819                 {
03820                     fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" );
03821                     PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." );
03822                     *tx = *ty = 0;
03823                 }
03824                 else
03825                 {
03826                     PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
03827                     *tx = t[0];
03828                     *ty = t[1];
03829                     Py_CLEAR( tmp );
03830                 }
03831             }
03832             // release the result
03833             Py_CLEAR( result );
03834             // release the global interpreter lock
03835             MY_UNBLOCK_THREADS
03836         }
03837     }
03838 
03839     PLFLT do_f2eval_callback( PLINT x, PLINT y, PLPointer data )
03840     {
03841         PyObject *pdata, *arglist, *result;
03842         PLFLT    fresult = 0.0;
03843 
03844         // the data argument is acutally a pointer to a python object
03845         pdata = (PyObject *) data;
03846         if ( python_f2eval ) // if not something is terribly wrong
03847         {                    // hold a reference to the data object
03848             Py_XINCREF( pdata );
03849             // grab the Global Interpreter Lock to be sure threads don't mess us up
03850             MY_BLOCK_THREADS
03851             // build the argument list
03852                 arglist = Py_BuildValue( "(iiO)", x, y, pdata );
03853             // call the python function
03854             result = PyEval_CallObject( python_f2eval, arglist );
03855             // release the argument list
03856             Py_CLEAR( arglist );
03857             // check and unpack the result
03858             if ( !PyFloat_Check( result ) )
03859             {
03860                 fprintf( stderr, "f2eval callback must return a float\n" );
03861                 PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." );
03862             }
03863             else
03864             {
03865                 // should I test the type here?
03866                 fresult = (PLFLT) PyFloat_AsDouble( result );
03867             }
03868             // release the result
03869             Py_CLEAR( result );
03870             // release the global interpreter lock
03871             MY_UNBLOCK_THREADS
03872         }
03873         return fresult;
03874     }
03875 
03876     void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
03877     {
03878         PyObject *pdata, *arglist, *result;
03879         char     *pystring;
03880 
03881         // the data argument is acutally a pointer to a python object
03882         if ( data )
03883             pdata = (PyObject *) data;
03884         else
03885             pdata = Py_None;
03886         if ( python_label ) // if not something is terribly wrong
03887         {                   // hold a reference to the data object
03888             Py_XINCREF( pdata );
03889             // grab the Global Interpreter Lock to be sure threads don't mess us up
03890             MY_BLOCK_THREADS
03891             // build the argument list
03892 #ifdef PL_DOUBLE
03893             arglist = Py_BuildValue( "(ldO)", axis, value, pdata );
03894 #else
03895             arglist = Py_BuildValue( "(lfO)", axis, value, pdata );
03896 #endif
03897             // call the python function
03898             result = PyEval_CallObject( python_label, arglist );
03899             // release the argument list
03900             //Py_CLEAR(arglist);
03901             // check and unpack the result
03902             if ( result == NULL )
03903             {
03904                 fprintf( stderr, "label callback failed with 3 arguments\n" );
03905                 PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." );
03906             }
03907             else if ( !PyString_Check( result ) )
03908             {
03909                 fprintf( stderr, "label callback must return a string\n" );
03910                 PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." );
03911             }
03912             else
03913             {
03914                 // should I test the type here?
03915                 pystring = PyString_AsString( result );
03916                 strncpy( string, pystring, len );
03917             }
03918             // release the result
03919             Py_CLEAR( result );
03920             // release the global interpreter lock
03921             MY_UNBLOCK_THREADS
03922         }
03923     }
03924 
03925     void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
03926     {
03927         PyObject *px, *py, *pdata, *arglist, *result;
03928         npy_intp n;
03929         n = 1;
03930 
03931         // the data argument is acutally a pointer to a python object
03932         pdata = (PyObject *) data;
03933         if ( data == NULL )
03934         {
03935             pdata = Py_None;
03936         }
03937         if ( python_ct ) // if not something is terribly wrong
03938         {                // hold a reference to the data object
03939             Py_XINCREF( pdata );
03940             // grab the Global Interpreter Lock to be sure threads don't mess us up
03941             MY_BLOCK_THREADS
03942             // build the argument list
03943                 px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt );
03944             py      = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt );
03945             arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata );
03946             // call the python function
03947             result = PyEval_CallObject( python_ct, arglist );
03948             // release the argument list
03949             Py_CLEAR( arglist );
03950             Py_CLEAR( px );
03951             Py_CLEAR( py );
03952             Py_CLEAR( pdata );
03953             // check and unpack the result
03954             if ( result == NULL )
03955             {
03956                 fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" );
03957                 PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." );
03958             }
03959             // release the result
03960             Py_CLEAR( result );
03961             // release the global interpreter lock
03962             MY_UNBLOCK_THREADS
03963         }
03964     }
03965 
03966     void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y )
03967     {
03968         PyObject *px, *py, *arglist, *result;
03969         // PyArrayObject *tmpx, *tmpy;
03970 //        PLFLT *xx, *yy;
03971 //        PLINT i;
03972         npy_intp nn;
03973         nn = n;
03974 
03975         if ( python_mapform ) // if not something is terribly wrong
03976         {                     // grab the Global Interpreter Lock to be sure threads don't mess us up
03977             MY_BLOCK_THREADS
03978             // build the argument list
03979 #ifdef PL_HAVE_PTHREAD
03980             px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x );
03981             py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y );
03982 #else
03983             px = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) x );
03984             py = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) y );
03985 #endif
03986             arglist = Py_BuildValue( "(iOO)", n, px, py );
03987             // call the python function
03988             result = PyEval_CallObject( python_mapform, arglist );
03989             // release the argument list
03990             Py_CLEAR( arglist );
03991             Py_CLEAR( px );
03992             Py_CLEAR( py );
03993             // check and unpack the result
03994             if ( result == NULL )
03995             {
03996                 fprintf( stderr, "call to python mapform function with 3 arguments failed\n" );
03997                 PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." );
03998             }
03999             // release the result
04000             Py_CLEAR( result );
04001             // release the global interpreter lock
04002             MY_UNBLOCK_THREADS
04003         }
04004     }
04005 
04006 // marshal the pltr function pointer argument
04007     pltr_func marshal_pltr( PyObject* input )
04008     {
04009         pltr_func result = do_pltr_callback;
04010         PyObject  * rep  = PyObject_Repr( input );
04011         if ( rep )
04012         {
04013             char* str = PyString_AsString( rep );
04014             if ( strcmp( str, "<built-in function pltr0>" ) == 0 )
04015             {
04016                 result      = pltr0;
04017                 pltr_type   = CB_0;
04018                 python_pltr = NULL;
04019             }
04020             else if ( strcmp( str, "<built-in function pltr1>" ) == 0 )
04021             {
04022                 result      = pltr1;
04023                 pltr_type   = CB_1;
04024                 python_pltr = NULL;
04025             }
04026             else if ( strcmp( str, "<built-in function pltr2>" ) == 0 )
04027             {
04028                 result      = pltr2;
04029                 pltr_type   = CB_2;
04030                 python_pltr = NULL;
04031             }
04032             else
04033             {
04034                 python_pltr = input;
04035                 pltr_type   = CB_Python;
04036                 Py_XINCREF( input );
04037             }
04038             Py_CLEAR( rep );
04039         }
04040         else
04041         {
04042             python_pltr = input;
04043             pltr_type   = CB_Python;
04044             Py_XINCREF( input );
04045         }
04046         return result;
04047     }
04048 
04049     void cleanup_pltr( void )
04050     {
04051         Py_CLEAR( python_pltr );
04052         python_pltr = 0;
04053     }
04054 
04055 // marshal the ct function pointer argument
04056     ct_func marshal_ct( PyObject* input )
04057     {
04058         ct_func result = do_ct_callback;
04059         python_ct = input;
04060         Py_XINCREF( input );
04061         return result;
04062     }
04063 
04064     void cleanup_ct( void )
04065     {
04066         Py_CLEAR( python_ct );
04067         python_ct = 0;
04068     }
04069 
04070 // marshal the mapform function pointer argument
04071     mapform_func marshal_mapform( PyObject* input )
04072     {
04073         mapform_func result = do_mapform_callback;
04074         python_mapform = input;
04075         Py_XINCREF( input );
04076         return result;
04077     }
04078 
04079     void cleanup_mapform( void )
04080     {
04081         Py_CLEAR( python_mapform );
04082         python_mapform = 0;
04083     }
04084 
04085     PLPointer marshal_PLPointer( PyObject* input, int isimg )
04086     {
04087         PLPointer result = NULL;
04088         switch ( pltr_type )
04089         {
04090         case CB_0:
04091             break;
04092         case CB_1:
04093             if ( input != Py_None )
04094                 result = marshal_PLcGrid1( input, isimg );
04095             break;
04096         case CB_2:
04097             if ( input != Py_None )
04098                 result = marshal_PLcGrid2( input, isimg );
04099             break;
04100         case CB_Python:
04101             Py_XINCREF( input );
04102             result = (PLPointer *) input;
04103             break;
04104         default:
04105             fprintf( stderr, "pltr_type is invalid\n" );
04106         }
04107         return result;
04108     }
04109 
04110     void cleanup_PLPointer( void )
04111     {
04112         switch ( pltr_type )
04113         {
04114         case CB_0:
04115             break;
04116         case CB_1:
04117             cleanup_PLcGrid1();
04118             break;
04119         case CB_2:
04120             cleanup_PLcGrid2();
04121             break;
04122         case CB_Python:
04123             Py_CLEAR( python_pltr );
04124             break;
04125         default:
04126             fprintf( stderr, "pltr_type is invalid\n" );
04127         }
04128         python_pltr = 0;
04129         pltr_type   = CB_0;
04130     }
04131 
04132 
04133 
04134 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04135   PyObject *resultobj = 0;
04136   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04137   int arg2 ;
04138   void *argp1 = 0 ;
04139   int res1 = 0 ;
04140   int val2 ;
04141   int ecode2 = 0 ;
04142   PyObject * obj0 = 0 ;
04143   PyObject * obj1 = 0 ;
04144   
04145   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_type_set",&obj0,&obj1)) SWIG_fail;
04146   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04147   if (!SWIG_IsOK(res1)) {
04148     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04149   }
04150   arg1 = (PLGraphicsIn *)(argp1);
04151   ecode2 = SWIG_AsVal_int(obj1, &val2);
04152   if (!SWIG_IsOK(ecode2)) {
04153     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
04154   } 
04155   arg2 = (int)(val2);
04156   if (arg1) (arg1)->type = arg2;
04157   resultobj = SWIG_Py_Void();
04158   return resultobj;
04159 fail:
04160   return NULL;
04161 }
04162 
04163 
04164 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04165   PyObject *resultobj = 0;
04166   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04167   void *argp1 = 0 ;
04168   int res1 = 0 ;
04169   PyObject * obj0 = 0 ;
04170   int result;
04171   
04172   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_type_get",&obj0)) SWIG_fail;
04173   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04174   if (!SWIG_IsOK(res1)) {
04175     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04176   }
04177   arg1 = (PLGraphicsIn *)(argp1);
04178   result = (int) ((arg1)->type);
04179   resultobj = SWIG_From_int((int)(result));
04180   return resultobj;
04181 fail:
04182   return NULL;
04183 }
04184 
04185 
04186 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04187   PyObject *resultobj = 0;
04188   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04189   unsigned int arg2 ;
04190   void *argp1 = 0 ;
04191   int res1 = 0 ;
04192   unsigned int val2 ;
04193   int ecode2 = 0 ;
04194   PyObject * obj0 = 0 ;
04195   PyObject * obj1 = 0 ;
04196   
04197   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_state_set",&obj0,&obj1)) SWIG_fail;
04198   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04199   if (!SWIG_IsOK(res1)) {
04200     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04201   }
04202   arg1 = (PLGraphicsIn *)(argp1);
04203   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
04204   if (!SWIG_IsOK(ecode2)) {
04205     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
04206   } 
04207   arg2 = (unsigned int)(val2);
04208   if (arg1) (arg1)->state = arg2;
04209   resultobj = SWIG_Py_Void();
04210   return resultobj;
04211 fail:
04212   return NULL;
04213 }
04214 
04215 
04216 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04217   PyObject *resultobj = 0;
04218   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04219   void *argp1 = 0 ;
04220   int res1 = 0 ;
04221   PyObject * obj0 = 0 ;
04222   unsigned int result;
04223   
04224   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_state_get",&obj0)) SWIG_fail;
04225   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04226   if (!SWIG_IsOK(res1)) {
04227     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04228   }
04229   arg1 = (PLGraphicsIn *)(argp1);
04230   result = (unsigned int) ((arg1)->state);
04231   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
04232   return resultobj;
04233 fail:
04234   return NULL;
04235 }
04236 
04237 
04238 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04239   PyObject *resultobj = 0;
04240   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04241   unsigned int arg2 ;
04242   void *argp1 = 0 ;
04243   int res1 = 0 ;
04244   unsigned int val2 ;
04245   int ecode2 = 0 ;
04246   PyObject * obj0 = 0 ;
04247   PyObject * obj1 = 0 ;
04248   
04249   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_keysym_set",&obj0,&obj1)) SWIG_fail;
04250   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04251   if (!SWIG_IsOK(res1)) {
04252     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04253   }
04254   arg1 = (PLGraphicsIn *)(argp1);
04255   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
04256   if (!SWIG_IsOK(ecode2)) {
04257     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
04258   } 
04259   arg2 = (unsigned int)(val2);
04260   if (arg1) (arg1)->keysym = arg2;
04261   resultobj = SWIG_Py_Void();
04262   return resultobj;
04263 fail:
04264   return NULL;
04265 }
04266 
04267 
04268 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04269   PyObject *resultobj = 0;
04270   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04271   void *argp1 = 0 ;
04272   int res1 = 0 ;
04273   PyObject * obj0 = 0 ;
04274   unsigned int result;
04275   
04276   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_keysym_get",&obj0)) SWIG_fail;
04277   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04278   if (!SWIG_IsOK(res1)) {
04279     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04280   }
04281   arg1 = (PLGraphicsIn *)(argp1);
04282   result = (unsigned int) ((arg1)->keysym);
04283   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
04284   return resultobj;
04285 fail:
04286   return NULL;
04287 }
04288 
04289 
04290 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04291   PyObject *resultobj = 0;
04292   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04293   unsigned int arg2 ;
04294   void *argp1 = 0 ;
04295   int res1 = 0 ;
04296   unsigned int val2 ;
04297   int ecode2 = 0 ;
04298   PyObject * obj0 = 0 ;
04299   PyObject * obj1 = 0 ;
04300   
04301   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_button_set",&obj0,&obj1)) SWIG_fail;
04302   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04303   if (!SWIG_IsOK(res1)) {
04304     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04305   }
04306   arg1 = (PLGraphicsIn *)(argp1);
04307   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
04308   if (!SWIG_IsOK(ecode2)) {
04309     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
04310   } 
04311   arg2 = (unsigned int)(val2);
04312   if (arg1) (arg1)->button = arg2;
04313   resultobj = SWIG_Py_Void();
04314   return resultobj;
04315 fail:
04316   return NULL;
04317 }
04318 
04319 
04320 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04321   PyObject *resultobj = 0;
04322   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04323   void *argp1 = 0 ;
04324   int res1 = 0 ;
04325   PyObject * obj0 = 0 ;
04326   unsigned int result;
04327   
04328   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_button_get",&obj0)) SWIG_fail;
04329   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04330   if (!SWIG_IsOK(res1)) {
04331     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04332   }
04333   arg1 = (PLGraphicsIn *)(argp1);
04334   result = (unsigned int) ((arg1)->button);
04335   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
04336   return resultobj;
04337 fail:
04338   return NULL;
04339 }
04340 
04341 
04342 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04343   PyObject *resultobj = 0;
04344   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04345   PLINT arg2 ;
04346   void *argp1 = 0 ;
04347   int res1 = 0 ;
04348   int val2 ;
04349   int ecode2 = 0 ;
04350   PyObject * obj0 = 0 ;
04351   PyObject * obj1 = 0 ;
04352   
04353   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_subwindow_set",&obj0,&obj1)) SWIG_fail;
04354   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04355   if (!SWIG_IsOK(res1)) {
04356     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04357   }
04358   arg1 = (PLGraphicsIn *)(argp1);
04359   ecode2 = SWIG_AsVal_int(obj1, &val2);
04360   if (!SWIG_IsOK(ecode2)) {
04361     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
04362   } 
04363   arg2 = (PLINT)(val2);
04364   if (arg1) (arg1)->subwindow = arg2;
04365   resultobj = SWIG_Py_Void();
04366   return resultobj;
04367 fail:
04368   return NULL;
04369 }
04370 
04371 
04372 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04373   PyObject *resultobj = 0;
04374   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04375   void *argp1 = 0 ;
04376   int res1 = 0 ;
04377   PyObject * obj0 = 0 ;
04378   PLINT result;
04379   
04380   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_subwindow_get",&obj0)) SWIG_fail;
04381   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04382   if (!SWIG_IsOK(res1)) {
04383     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04384   }
04385   arg1 = (PLGraphicsIn *)(argp1);
04386   result = (PLINT) ((arg1)->subwindow);
04387   resultobj = SWIG_From_int((int)(result));
04388   return resultobj;
04389 fail:
04390   return NULL;
04391 }
04392 
04393 
04394 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04395   PyObject *resultobj = 0;
04396   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04397   char *arg2 ;
04398   void *argp1 = 0 ;
04399   int res1 = 0 ;
04400   char temp2[16] ;
04401   int res2 ;
04402   PyObject * obj0 = 0 ;
04403   PyObject * obj1 = 0 ;
04404   
04405   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_string_set",&obj0,&obj1)) SWIG_fail;
04406   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04407   if (!SWIG_IsOK(res1)) {
04408     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04409   }
04410   arg1 = (PLGraphicsIn *)(argp1);
04411   res2 = SWIG_AsCharArray(obj1, temp2, 16);
04412   if (!SWIG_IsOK(res2)) {
04413     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
04414   }
04415   arg2 = (char *)(temp2);
04416   if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
04417   else memset(arg1->string,0,16*sizeof(char));
04418   resultobj = SWIG_Py_Void();
04419   return resultobj;
04420 fail:
04421   return NULL;
04422 }
04423 
04424 
04425 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04426   PyObject *resultobj = 0;
04427   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04428   void *argp1 = 0 ;
04429   int res1 = 0 ;
04430   PyObject * obj0 = 0 ;
04431   char *result = 0 ;
04432   
04433   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_string_get",&obj0)) SWIG_fail;
04434   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04435   if (!SWIG_IsOK(res1)) {
04436     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04437   }
04438   arg1 = (PLGraphicsIn *)(argp1);
04439   result = (char *)(char *) ((arg1)->string);
04440   {
04441     size_t size = SWIG_strnlen(result, 16);
04442     
04443     
04444     
04445     resultobj = SWIG_FromCharPtrAndSize(result, size);
04446   }
04447   return resultobj;
04448 fail:
04449   return NULL;
04450 }
04451 
04452 
04453 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04454   PyObject *resultobj = 0;
04455   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04456   int arg2 ;
04457   void *argp1 = 0 ;
04458   int res1 = 0 ;
04459   int val2 ;
04460   int ecode2 = 0 ;
04461   PyObject * obj0 = 0 ;
04462   PyObject * obj1 = 0 ;
04463   
04464   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pX_set",&obj0,&obj1)) SWIG_fail;
04465   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04466   if (!SWIG_IsOK(res1)) {
04467     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04468   }
04469   arg1 = (PLGraphicsIn *)(argp1);
04470   ecode2 = SWIG_AsVal_int(obj1, &val2);
04471   if (!SWIG_IsOK(ecode2)) {
04472     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
04473   } 
04474   arg2 = (int)(val2);
04475   if (arg1) (arg1)->pX = arg2;
04476   resultobj = SWIG_Py_Void();
04477   return resultobj;
04478 fail:
04479   return NULL;
04480 }
04481 
04482 
04483 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04484   PyObject *resultobj = 0;
04485   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04486   void *argp1 = 0 ;
04487   int res1 = 0 ;
04488   PyObject * obj0 = 0 ;
04489   int result;
04490   
04491   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pX_get",&obj0)) SWIG_fail;
04492   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04493   if (!SWIG_IsOK(res1)) {
04494     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04495   }
04496   arg1 = (PLGraphicsIn *)(argp1);
04497   result = (int) ((arg1)->pX);
04498   resultobj = SWIG_From_int((int)(result));
04499   return resultobj;
04500 fail:
04501   return NULL;
04502 }
04503 
04504 
04505 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04506   PyObject *resultobj = 0;
04507   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04508   int arg2 ;
04509   void *argp1 = 0 ;
04510   int res1 = 0 ;
04511   int val2 ;
04512   int ecode2 = 0 ;
04513   PyObject * obj0 = 0 ;
04514   PyObject * obj1 = 0 ;
04515   
04516   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_pY_set",&obj0,&obj1)) SWIG_fail;
04517   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04518   if (!SWIG_IsOK(res1)) {
04519     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04520   }
04521   arg1 = (PLGraphicsIn *)(argp1);
04522   ecode2 = SWIG_AsVal_int(obj1, &val2);
04523   if (!SWIG_IsOK(ecode2)) {
04524     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
04525   } 
04526   arg2 = (int)(val2);
04527   if (arg1) (arg1)->pY = arg2;
04528   resultobj = SWIG_Py_Void();
04529   return resultobj;
04530 fail:
04531   return NULL;
04532 }
04533 
04534 
04535 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04536   PyObject *resultobj = 0;
04537   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04538   void *argp1 = 0 ;
04539   int res1 = 0 ;
04540   PyObject * obj0 = 0 ;
04541   int result;
04542   
04543   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_pY_get",&obj0)) SWIG_fail;
04544   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04545   if (!SWIG_IsOK(res1)) {
04546     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04547   }
04548   arg1 = (PLGraphicsIn *)(argp1);
04549   result = (int) ((arg1)->pY);
04550   resultobj = SWIG_From_int((int)(result));
04551   return resultobj;
04552 fail:
04553   return NULL;
04554 }
04555 
04556 
04557 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04558   PyObject *resultobj = 0;
04559   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04560   PLFLT arg2 ;
04561   void *argp1 = 0 ;
04562   int res1 = 0 ;
04563   double val2 ;
04564   int ecode2 = 0 ;
04565   PyObject * obj0 = 0 ;
04566   PyObject * obj1 = 0 ;
04567   
04568   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dX_set",&obj0,&obj1)) SWIG_fail;
04569   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04570   if (!SWIG_IsOK(res1)) {
04571     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04572   }
04573   arg1 = (PLGraphicsIn *)(argp1);
04574   ecode2 = SWIG_AsVal_double(obj1, &val2);
04575   if (!SWIG_IsOK(ecode2)) {
04576     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
04577   } 
04578   arg2 = (PLFLT)(val2);
04579   if (arg1) (arg1)->dX = arg2;
04580   resultobj = SWIG_Py_Void();
04581   return resultobj;
04582 fail:
04583   return NULL;
04584 }
04585 
04586 
04587 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04588   PyObject *resultobj = 0;
04589   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04590   void *argp1 = 0 ;
04591   int res1 = 0 ;
04592   PyObject * obj0 = 0 ;
04593   PLFLT result;
04594   
04595   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dX_get",&obj0)) SWIG_fail;
04596   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04597   if (!SWIG_IsOK(res1)) {
04598     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04599   }
04600   arg1 = (PLGraphicsIn *)(argp1);
04601   result = (PLFLT) ((arg1)->dX);
04602   resultobj = SWIG_From_double((double)(result));
04603   return resultobj;
04604 fail:
04605   return NULL;
04606 }
04607 
04608 
04609 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04610   PyObject *resultobj = 0;
04611   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04612   PLFLT arg2 ;
04613   void *argp1 = 0 ;
04614   int res1 = 0 ;
04615   double val2 ;
04616   int ecode2 = 0 ;
04617   PyObject * obj0 = 0 ;
04618   PyObject * obj1 = 0 ;
04619   
04620   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_dY_set",&obj0,&obj1)) SWIG_fail;
04621   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04622   if (!SWIG_IsOK(res1)) {
04623     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04624   }
04625   arg1 = (PLGraphicsIn *)(argp1);
04626   ecode2 = SWIG_AsVal_double(obj1, &val2);
04627   if (!SWIG_IsOK(ecode2)) {
04628     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
04629   } 
04630   arg2 = (PLFLT)(val2);
04631   if (arg1) (arg1)->dY = arg2;
04632   resultobj = SWIG_Py_Void();
04633   return resultobj;
04634 fail:
04635   return NULL;
04636 }
04637 
04638 
04639 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04640   PyObject *resultobj = 0;
04641   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04642   void *argp1 = 0 ;
04643   int res1 = 0 ;
04644   PyObject * obj0 = 0 ;
04645   PLFLT result;
04646   
04647   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_dY_get",&obj0)) SWIG_fail;
04648   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04649   if (!SWIG_IsOK(res1)) {
04650     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04651   }
04652   arg1 = (PLGraphicsIn *)(argp1);
04653   result = (PLFLT) ((arg1)->dY);
04654   resultobj = SWIG_From_double((double)(result));
04655   return resultobj;
04656 fail:
04657   return NULL;
04658 }
04659 
04660 
04661 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04662   PyObject *resultobj = 0;
04663   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04664   PLFLT arg2 ;
04665   void *argp1 = 0 ;
04666   int res1 = 0 ;
04667   double val2 ;
04668   int ecode2 = 0 ;
04669   PyObject * obj0 = 0 ;
04670   PyObject * obj1 = 0 ;
04671   
04672   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wX_set",&obj0,&obj1)) SWIG_fail;
04673   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04674   if (!SWIG_IsOK(res1)) {
04675     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04676   }
04677   arg1 = (PLGraphicsIn *)(argp1);
04678   ecode2 = SWIG_AsVal_double(obj1, &val2);
04679   if (!SWIG_IsOK(ecode2)) {
04680     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
04681   } 
04682   arg2 = (PLFLT)(val2);
04683   if (arg1) (arg1)->wX = arg2;
04684   resultobj = SWIG_Py_Void();
04685   return resultobj;
04686 fail:
04687   return NULL;
04688 }
04689 
04690 
04691 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04692   PyObject *resultobj = 0;
04693   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04694   void *argp1 = 0 ;
04695   int res1 = 0 ;
04696   PyObject * obj0 = 0 ;
04697   PLFLT result;
04698   
04699   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wX_get",&obj0)) SWIG_fail;
04700   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04701   if (!SWIG_IsOK(res1)) {
04702     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04703   }
04704   arg1 = (PLGraphicsIn *)(argp1);
04705   result = (PLFLT) ((arg1)->wX);
04706   resultobj = SWIG_From_double((double)(result));
04707   return resultobj;
04708 fail:
04709   return NULL;
04710 }
04711 
04712 
04713 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04714   PyObject *resultobj = 0;
04715   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04716   PLFLT arg2 ;
04717   void *argp1 = 0 ;
04718   int res1 = 0 ;
04719   double val2 ;
04720   int ecode2 = 0 ;
04721   PyObject * obj0 = 0 ;
04722   PyObject * obj1 = 0 ;
04723   
04724   if (!PyArg_ParseTuple(args,(char *)"OO:PLGraphicsIn_wY_set",&obj0,&obj1)) SWIG_fail;
04725   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04726   if (!SWIG_IsOK(res1)) {
04727     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04728   }
04729   arg1 = (PLGraphicsIn *)(argp1);
04730   ecode2 = SWIG_AsVal_double(obj1, &val2);
04731   if (!SWIG_IsOK(ecode2)) {
04732     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
04733   } 
04734   arg2 = (PLFLT)(val2);
04735   if (arg1) (arg1)->wY = arg2;
04736   resultobj = SWIG_Py_Void();
04737   return resultobj;
04738 fail:
04739   return NULL;
04740 }
04741 
04742 
04743 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04744   PyObject *resultobj = 0;
04745   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04746   void *argp1 = 0 ;
04747   int res1 = 0 ;
04748   PyObject * obj0 = 0 ;
04749   PLFLT result;
04750   
04751   if (!PyArg_ParseTuple(args,(char *)"O:PLGraphicsIn_wY_get",&obj0)) SWIG_fail;
04752   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
04753   if (!SWIG_IsOK(res1)) {
04754     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04755   }
04756   arg1 = (PLGraphicsIn *)(argp1);
04757   result = (PLFLT) ((arg1)->wY);
04758   resultobj = SWIG_From_double((double)(result));
04759   return resultobj;
04760 fail:
04761   return NULL;
04762 }
04763 
04764 
04765 SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04766   PyObject *resultobj = 0;
04767   PLGraphicsIn *result = 0 ;
04768   
04769   if (!PyArg_ParseTuple(args,(char *)":new_PLGraphicsIn")) SWIG_fail;
04770   result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
04771   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_NEW |  0 );
04772   return resultobj;
04773 fail:
04774   return NULL;
04775 }
04776 
04777 
04778 SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04779   PyObject *resultobj = 0;
04780   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
04781   void *argp1 = 0 ;
04782   int res1 = 0 ;
04783   PyObject * obj0 = 0 ;
04784   
04785   if (!PyArg_ParseTuple(args,(char *)"O:delete_PLGraphicsIn",&obj0)) SWIG_fail;
04786   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN |  0 );
04787   if (!SWIG_IsOK(res1)) {
04788     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
04789   }
04790   arg1 = (PLGraphicsIn *)(argp1);
04791   free((char *) arg1);
04792   resultobj = SWIG_Py_Void();
04793   return resultobj;
04794 fail:
04795   return NULL;
04796 }
04797 
04798 
04799 SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04800   PyObject *obj;
04801   if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
04802   SWIG_TypeNewClientData(SWIGTYPE_p_PLGraphicsIn, SWIG_NewClientData(obj));
04803   return SWIG_Py_Void();
04804 }
04805 
04806 SWIGINTERN PyObject *_wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04807   PyObject *resultobj = 0;
04808   PLINT arg1 ;
04809   int val1 ;
04810   int ecode1 = 0 ;
04811   PyObject * obj0 = 0 ;
04812   
04813   if (!PyArg_ParseTuple(args,(char *)"O:plsxwin",&obj0)) SWIG_fail;
04814   ecode1 = SWIG_AsVal_int(obj0, &val1);
04815   if (!SWIG_IsOK(ecode1)) {
04816     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'");
04817   } 
04818   arg1 = (PLINT)(val1);
04819   plsxwin(arg1);
04820   resultobj = SWIG_Py_Void();
04821   return resultobj;
04822 fail:
04823   return NULL;
04824 }
04825 
04826 
04827 SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04828   PyObject *resultobj = 0;
04829   PLINT arg1 ;
04830   PLINT arg2 ;
04831   int val1 ;
04832   int ecode1 = 0 ;
04833   int val2 ;
04834   int ecode2 = 0 ;
04835   PyObject * obj0 = 0 ;
04836   PyObject * obj1 = 0 ;
04837   
04838   if (!PyArg_ParseTuple(args,(char *)"OO:pl_setcontlabelformat",&obj0,&obj1)) SWIG_fail;
04839   ecode1 = SWIG_AsVal_int(obj0, &val1);
04840   if (!SWIG_IsOK(ecode1)) {
04841     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
04842   } 
04843   arg1 = (PLINT)(val1);
04844   ecode2 = SWIG_AsVal_int(obj1, &val2);
04845   if (!SWIG_IsOK(ecode2)) {
04846     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
04847   } 
04848   arg2 = (PLINT)(val2);
04849   pl_setcontlabelformat(arg1,arg2);
04850   resultobj = SWIG_Py_Void();
04851   return resultobj;
04852 fail:
04853   return NULL;
04854 }
04855 
04856 
04857 SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04858   PyObject *resultobj = 0;
04859   PLFLT arg1 ;
04860   PLFLT arg2 ;
04861   PLFLT arg3 ;
04862   PLINT arg4 ;
04863   double val1 ;
04864   int ecode1 = 0 ;
04865   double val2 ;
04866   int ecode2 = 0 ;
04867   double val3 ;
04868   int ecode3 = 0 ;
04869   int val4 ;
04870   int ecode4 = 0 ;
04871   PyObject * obj0 = 0 ;
04872   PyObject * obj1 = 0 ;
04873   PyObject * obj2 = 0 ;
04874   PyObject * obj3 = 0 ;
04875   
04876   if (!PyArg_ParseTuple(args,(char *)"OOOO:pl_setcontlabelparam",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
04877   ecode1 = SWIG_AsVal_double(obj0, &val1);
04878   if (!SWIG_IsOK(ecode1)) {
04879     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
04880   } 
04881   arg1 = (PLFLT)(val1);
04882   ecode2 = SWIG_AsVal_double(obj1, &val2);
04883   if (!SWIG_IsOK(ecode2)) {
04884     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
04885   } 
04886   arg2 = (PLFLT)(val2);
04887   ecode3 = SWIG_AsVal_double(obj2, &val3);
04888   if (!SWIG_IsOK(ecode3)) {
04889     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
04890   } 
04891   arg3 = (PLFLT)(val3);
04892   ecode4 = SWIG_AsVal_int(obj3, &val4);
04893   if (!SWIG_IsOK(ecode4)) {
04894     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
04895   } 
04896   arg4 = (PLINT)(val4);
04897   pl_setcontlabelparam(arg1,arg2,arg3,arg4);
04898   resultobj = SWIG_Py_Void();
04899   return resultobj;
04900 fail:
04901   return NULL;
04902 }
04903 
04904 
04905 SWIGINTERN PyObject *_wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04906   PyObject *resultobj = 0;
04907   PLINT arg1 ;
04908   int val1 ;
04909   int ecode1 = 0 ;
04910   PyObject * obj0 = 0 ;
04911   
04912   if (!PyArg_ParseTuple(args,(char *)"O:pladv",&obj0)) SWIG_fail;
04913   ecode1 = SWIG_AsVal_int(obj0, &val1);
04914   if (!SWIG_IsOK(ecode1)) {
04915     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
04916   } 
04917   arg1 = (PLINT)(val1);
04918   pladv(arg1);
04919   resultobj = SWIG_Py_Void();
04920   return resultobj;
04921 fail:
04922   return NULL;
04923 }
04924 
04925 
04926 SWIGINTERN PyObject *_wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04927   PyObject *resultobj = 0;
04928   PLFLT arg1 ;
04929   PLFLT arg2 ;
04930   PLFLT arg3 ;
04931   PLFLT arg4 ;
04932   PLFLT arg5 ;
04933   PLFLT arg6 ;
04934   PLFLT arg7 ;
04935   PLBOOL arg8 ;
04936   double val1 ;
04937   int ecode1 = 0 ;
04938   double val2 ;
04939   int ecode2 = 0 ;
04940   double val3 ;
04941   int ecode3 = 0 ;
04942   double val4 ;
04943   int ecode4 = 0 ;
04944   double val5 ;
04945   int ecode5 = 0 ;
04946   double val6 ;
04947   int ecode6 = 0 ;
04948   double val7 ;
04949   int ecode7 = 0 ;
04950   int val8 ;
04951   int ecode8 = 0 ;
04952   PyObject * obj0 = 0 ;
04953   PyObject * obj1 = 0 ;
04954   PyObject * obj2 = 0 ;
04955   PyObject * obj3 = 0 ;
04956   PyObject * obj4 = 0 ;
04957   PyObject * obj5 = 0 ;
04958   PyObject * obj6 = 0 ;
04959   PyObject * obj7 = 0 ;
04960   
04961   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plarc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
04962   ecode1 = SWIG_AsVal_double(obj0, &val1);
04963   if (!SWIG_IsOK(ecode1)) {
04964     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
04965   } 
04966   arg1 = (PLFLT)(val1);
04967   ecode2 = SWIG_AsVal_double(obj1, &val2);
04968   if (!SWIG_IsOK(ecode2)) {
04969     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
04970   } 
04971   arg2 = (PLFLT)(val2);
04972   ecode3 = SWIG_AsVal_double(obj2, &val3);
04973   if (!SWIG_IsOK(ecode3)) {
04974     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
04975   } 
04976   arg3 = (PLFLT)(val3);
04977   ecode4 = SWIG_AsVal_double(obj3, &val4);
04978   if (!SWIG_IsOK(ecode4)) {
04979     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
04980   } 
04981   arg4 = (PLFLT)(val4);
04982   ecode5 = SWIG_AsVal_double(obj4, &val5);
04983   if (!SWIG_IsOK(ecode5)) {
04984     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
04985   } 
04986   arg5 = (PLFLT)(val5);
04987   ecode6 = SWIG_AsVal_double(obj5, &val6);
04988   if (!SWIG_IsOK(ecode6)) {
04989     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
04990   } 
04991   arg6 = (PLFLT)(val6);
04992   ecode7 = SWIG_AsVal_double(obj6, &val7);
04993   if (!SWIG_IsOK(ecode7)) {
04994     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
04995   } 
04996   arg7 = (PLFLT)(val7);
04997   ecode8 = SWIG_AsVal_int(obj7, &val8);
04998   if (!SWIG_IsOK(ecode8)) {
04999     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
05000   } 
05001   arg8 = (PLBOOL)(val8);
05002   plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
05003   resultobj = SWIG_Py_Void();
05004   return resultobj;
05005 fail:
05006   return NULL;
05007 }
05008 
05009 
05010 SWIGINTERN PyObject *_wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05011   PyObject *resultobj = 0;
05012   PLFLT arg1 ;
05013   PLFLT arg2 ;
05014   char *arg3 = (char *) 0 ;
05015   PLFLT arg4 ;
05016   PLINT arg5 ;
05017   char *arg6 = (char *) 0 ;
05018   PLFLT arg7 ;
05019   PLINT arg8 ;
05020   double val1 ;
05021   int ecode1 = 0 ;
05022   double val2 ;
05023   int ecode2 = 0 ;
05024   int res3 ;
05025   char *buf3 = 0 ;
05026   int alloc3 = 0 ;
05027   double val4 ;
05028   int ecode4 = 0 ;
05029   int val5 ;
05030   int ecode5 = 0 ;
05031   int res6 ;
05032   char *buf6 = 0 ;
05033   int alloc6 = 0 ;
05034   double val7 ;
05035   int ecode7 = 0 ;
05036   int val8 ;
05037   int ecode8 = 0 ;
05038   PyObject * obj0 = 0 ;
05039   PyObject * obj1 = 0 ;
05040   PyObject * obj2 = 0 ;
05041   PyObject * obj3 = 0 ;
05042   PyObject * obj4 = 0 ;
05043   PyObject * obj5 = 0 ;
05044   PyObject * obj6 = 0 ;
05045   PyObject * obj7 = 0 ;
05046   
05047   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plaxes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
05048   ecode1 = SWIG_AsVal_double(obj0, &val1);
05049   if (!SWIG_IsOK(ecode1)) {
05050     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
05051   } 
05052   arg1 = (PLFLT)(val1);
05053   ecode2 = SWIG_AsVal_double(obj1, &val2);
05054   if (!SWIG_IsOK(ecode2)) {
05055     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
05056   } 
05057   arg2 = (PLFLT)(val2);
05058   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
05059   if (!SWIG_IsOK(res3)) {
05060     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
05061   }
05062   arg3 = (char *)(buf3);
05063   ecode4 = SWIG_AsVal_double(obj3, &val4);
05064   if (!SWIG_IsOK(ecode4)) {
05065     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
05066   } 
05067   arg4 = (PLFLT)(val4);
05068   ecode5 = SWIG_AsVal_int(obj4, &val5);
05069   if (!SWIG_IsOK(ecode5)) {
05070     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
05071   } 
05072   arg5 = (PLINT)(val5);
05073   res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
05074   if (!SWIG_IsOK(res6)) {
05075     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
05076   }
05077   arg6 = (char *)(buf6);
05078   ecode7 = SWIG_AsVal_double(obj6, &val7);
05079   if (!SWIG_IsOK(ecode7)) {
05080     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
05081   } 
05082   arg7 = (PLFLT)(val7);
05083   ecode8 = SWIG_AsVal_int(obj7, &val8);
05084   if (!SWIG_IsOK(ecode8)) {
05085     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
05086   } 
05087   arg8 = (PLINT)(val8);
05088   plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
05089   resultobj = SWIG_Py_Void();
05090   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
05091   if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
05092   return resultobj;
05093 fail:
05094   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
05095   if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
05096   return NULL;
05097 }
05098 
05099 
05100 SWIGINTERN PyObject *_wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05101   PyObject *resultobj = 0;
05102   PLINT arg1 ;
05103   PLFLT *arg2 = (PLFLT *) 0 ;
05104   PLFLT *arg3 = (PLFLT *) 0 ;
05105   PLINT arg4 ;
05106   PyArrayObject *tmp1 = NULL ;
05107   PyArrayObject *tmp3 = NULL ;
05108   int val4 ;
05109   int ecode4 = 0 ;
05110   PyObject * obj0 = 0 ;
05111   PyObject * obj1 = 0 ;
05112   PyObject * obj2 = 0 ;
05113   
05114   if (!PyArg_ParseTuple(args,(char *)"OOO:plbin",&obj0,&obj1,&obj2)) SWIG_fail;
05115   {
05116     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
05117     if ( tmp1 == NULL )
05118     return NULL;
05119     arg1 = Alen = PyArray_DIMS( tmp1 )[0];
05120     arg2 = (PLFLT *) PyArray_DATA( tmp1 );
05121   }
05122   {
05123     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
05124     if ( tmp3 == NULL )
05125     return NULL;
05126     if ( PyArray_DIMS( tmp3 )[0] != Alen )
05127     {
05128       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
05129       return NULL;
05130     }
05131     arg3 = (PLFLT *) PyArray_DATA( tmp3 );
05132   }
05133   ecode4 = SWIG_AsVal_int(obj2, &val4);
05134   if (!SWIG_IsOK(ecode4)) {
05135     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
05136   } 
05137   arg4 = (PLINT)(val4);
05138   plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
05139   resultobj = SWIG_Py_Void();
05140   {
05141     Py_CLEAR( tmp1 );
05142   }
05143   {
05144     Py_CLEAR( tmp3 );
05145   }
05146   return resultobj;
05147 fail:
05148   {
05149     Py_CLEAR( tmp1 );
05150   }
05151   {
05152     Py_CLEAR( tmp3 );
05153   }
05154   return NULL;
05155 }
05156 
05157 
05158 SWIGINTERN PyObject *_wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05159   PyObject *resultobj = 0;
05160   PLINT *arg1 = (PLINT *) 0 ;
05161   PLINT *arg2 = (PLINT *) 0 ;
05162   PLINT *arg3 = (PLINT *) 0 ;
05163   PLINT *arg4 = (PLINT *) 0 ;
05164   PLINT *arg5 = (PLINT *) 0 ;
05165   PLFLT *arg6 = (PLFLT *) 0 ;
05166   PLFLT arg7 ;
05167   PLINT temp1 ;
05168   int res1 = SWIG_TMPOBJ ;
05169   PLINT temp2 ;
05170   int res2 = SWIG_TMPOBJ ;
05171   PLINT temp3 ;
05172   int res3 = SWIG_TMPOBJ ;
05173   PLINT temp4 ;
05174   int res4 = SWIG_TMPOBJ ;
05175   PLINT temp5 ;
05176   int res5 = SWIG_TMPOBJ ;
05177   PLFLT temp6 ;
05178   int res6 = SWIG_TMPOBJ ;
05179   double val7 ;
05180   int ecode7 = 0 ;
05181   PyObject * obj0 = 0 ;
05182   
05183   arg1 = &temp1;
05184   arg2 = &temp2;
05185   arg3 = &temp3;
05186   arg4 = &temp4;
05187   arg5 = &temp5;
05188   arg6 = &temp6;
05189   if (!PyArg_ParseTuple(args,(char *)"O:plbtime",&obj0)) SWIG_fail;
05190   ecode7 = SWIG_AsVal_double(obj0, &val7);
05191   if (!SWIG_IsOK(ecode7)) {
05192     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
05193   } 
05194   arg7 = (PLFLT)(val7);
05195   plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
05196   resultobj = SWIG_Py_Void();
05197   if (SWIG_IsTmpObj(res1)) {
05198     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
05199   } else {
05200     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
05201     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
05202   }
05203   if (SWIG_IsTmpObj(res2)) {
05204     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
05205   } else {
05206     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
05207     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
05208   }
05209   if (SWIG_IsTmpObj(res3)) {
05210     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
05211   } else {
05212     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
05213     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
05214   }
05215   if (SWIG_IsTmpObj(res4)) {
05216     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
05217   } else {
05218     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
05219     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
05220   }
05221   if (SWIG_IsTmpObj(res5)) {
05222     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
05223   } else {
05224     int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
05225     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
05226   }
05227   if (SWIG_IsTmpObj(res6)) {
05228     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
05229   } else {
05230     int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
05231     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
05232   }
05233   return resultobj;
05234 fail:
05235   return NULL;
05236 }
05237 
05238 
05239 SWIGINTERN PyObject *_wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05240   PyObject *resultobj = 0;
05241   
05242   if (!PyArg_ParseTuple(args,(char *)":plbop")) SWIG_fail;
05243   plbop();
05244   resultobj = SWIG_Py_Void();
05245   return resultobj;
05246 fail:
05247   return NULL;
05248 }
05249 
05250 
05251 SWIGINTERN PyObject *_wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05252   PyObject *resultobj = 0;
05253   char *arg1 = (char *) 0 ;
05254   PLFLT arg2 ;
05255   PLINT arg3 ;
05256   char *arg4 = (char *) 0 ;
05257   PLFLT arg5 ;
05258   PLINT arg6 ;
05259   int res1 ;
05260   char *buf1 = 0 ;
05261   int alloc1 = 0 ;
05262   double val2 ;
05263   int ecode2 = 0 ;
05264   int val3 ;
05265   int ecode3 = 0 ;
05266   int res4 ;
05267   char *buf4 = 0 ;
05268   int alloc4 = 0 ;
05269   double val5 ;
05270   int ecode5 = 0 ;
05271   int val6 ;
05272   int ecode6 = 0 ;
05273   PyObject * obj0 = 0 ;
05274   PyObject * obj1 = 0 ;
05275   PyObject * obj2 = 0 ;
05276   PyObject * obj3 = 0 ;
05277   PyObject * obj4 = 0 ;
05278   PyObject * obj5 = 0 ;
05279   
05280   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plbox",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
05281   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
05282   if (!SWIG_IsOK(res1)) {
05283     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
05284   }
05285   arg1 = (char *)(buf1);
05286   ecode2 = SWIG_AsVal_double(obj1, &val2);
05287   if (!SWIG_IsOK(ecode2)) {
05288     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
05289   } 
05290   arg2 = (PLFLT)(val2);
05291   ecode3 = SWIG_AsVal_int(obj2, &val3);
05292   if (!SWIG_IsOK(ecode3)) {
05293     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
05294   } 
05295   arg3 = (PLINT)(val3);
05296   res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
05297   if (!SWIG_IsOK(res4)) {
05298     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
05299   }
05300   arg4 = (char *)(buf4);
05301   ecode5 = SWIG_AsVal_double(obj4, &val5);
05302   if (!SWIG_IsOK(ecode5)) {
05303     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
05304   } 
05305   arg5 = (PLFLT)(val5);
05306   ecode6 = SWIG_AsVal_int(obj5, &val6);
05307   if (!SWIG_IsOK(ecode6)) {
05308     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
05309   } 
05310   arg6 = (PLINT)(val6);
05311   plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
05312   resultobj = SWIG_Py_Void();
05313   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
05314   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
05315   return resultobj;
05316 fail:
05317   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
05318   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
05319   return NULL;
05320 }
05321 
05322 
05323 SWIGINTERN PyObject *_wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05324   PyObject *resultobj = 0;
05325   char *arg1 = (char *) 0 ;
05326   char *arg2 = (char *) 0 ;
05327   PLFLT arg3 ;
05328   PLINT arg4 ;
05329   char *arg5 = (char *) 0 ;
05330   char *arg6 = (char *) 0 ;
05331   PLFLT arg7 ;
05332   PLINT arg8 ;
05333   char *arg9 = (char *) 0 ;
05334   char *arg10 = (char *) 0 ;
05335   PLFLT arg11 ;
05336   PLINT arg12 ;
05337   int res1 ;
05338   char *buf1 = 0 ;
05339   int alloc1 = 0 ;
05340   int res2 ;
05341   char *buf2 = 0 ;
05342   int alloc2 = 0 ;
05343   double val3 ;
05344   int ecode3 = 0 ;
05345   int val4 ;
05346   int ecode4 = 0 ;
05347   int res5 ;
05348   char *buf5 = 0 ;
05349   int alloc5 = 0 ;
05350   int res6 ;
05351   char *buf6 = 0 ;
05352   int alloc6 = 0 ;
05353   double val7 ;
05354   int ecode7 = 0 ;
05355   int val8 ;
05356   int ecode8 = 0 ;
05357   int res9 ;
05358   char *buf9 = 0 ;
05359   int alloc9 = 0 ;
05360   int res10 ;
05361   char *buf10 = 0 ;
05362   int alloc10 = 0 ;
05363   double val11 ;
05364   int ecode11 = 0 ;
05365   int val12 ;
05366   int ecode12 = 0 ;
05367   PyObject * obj0 = 0 ;
05368   PyObject * obj1 = 0 ;
05369   PyObject * obj2 = 0 ;
05370   PyObject * obj3 = 0 ;
05371   PyObject * obj4 = 0 ;
05372   PyObject * obj5 = 0 ;
05373   PyObject * obj6 = 0 ;
05374   PyObject * obj7 = 0 ;
05375   PyObject * obj8 = 0 ;
05376   PyObject * obj9 = 0 ;
05377   PyObject * obj10 = 0 ;
05378   PyObject * obj11 = 0 ;
05379   
05380   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:plbox3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
05381   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
05382   if (!SWIG_IsOK(res1)) {
05383     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
05384   }
05385   arg1 = (char *)(buf1);
05386   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
05387   if (!SWIG_IsOK(res2)) {
05388     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
05389   }
05390   arg2 = (char *)(buf2);
05391   ecode3 = SWIG_AsVal_double(obj2, &val3);
05392   if (!SWIG_IsOK(ecode3)) {
05393     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
05394   } 
05395   arg3 = (PLFLT)(val3);
05396   ecode4 = SWIG_AsVal_int(obj3, &val4);
05397   if (!SWIG_IsOK(ecode4)) {
05398     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
05399   } 
05400   arg4 = (PLINT)(val4);
05401   res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
05402   if (!SWIG_IsOK(res5)) {
05403     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
05404   }
05405   arg5 = (char *)(buf5);
05406   res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
05407   if (!SWIG_IsOK(res6)) {
05408     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
05409   }
05410   arg6 = (char *)(buf6);
05411   ecode7 = SWIG_AsVal_double(obj6, &val7);
05412   if (!SWIG_IsOK(ecode7)) {
05413     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
05414   } 
05415   arg7 = (PLFLT)(val7);
05416   ecode8 = SWIG_AsVal_int(obj7, &val8);
05417   if (!SWIG_IsOK(ecode8)) {
05418     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
05419   } 
05420   arg8 = (PLINT)(val8);
05421   res9 = SWIG_AsCharPtrAndSize(obj8, &buf9, NULL, &alloc9);
05422   if (!SWIG_IsOK(res9)) {
05423     SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
05424   }
05425   arg9 = (char *)(buf9);
05426   res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
05427   if (!SWIG_IsOK(res10)) {
05428     SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
05429   }
05430   arg10 = (char *)(buf10);
05431   ecode11 = SWIG_AsVal_double(obj10, &val11);
05432   if (!SWIG_IsOK(ecode11)) {
05433     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
05434   } 
05435   arg11 = (PLFLT)(val11);
05436   ecode12 = SWIG_AsVal_int(obj11, &val12);
05437   if (!SWIG_IsOK(ecode12)) {
05438     SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
05439   } 
05440   arg12 = (PLINT)(val12);
05441   plbox3((char const *)arg1,(char const *)arg2,arg3,arg4,(char const *)arg5,(char const *)arg6,arg7,arg8,(char const *)arg9,(char const *)arg10,arg11,arg12);
05442   resultobj = SWIG_Py_Void();
05443   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
05444   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
05445   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
05446   if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
05447   if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
05448   if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
05449   return resultobj;
05450 fail:
05451   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
05452   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
05453   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
05454   if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
05455   if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
05456   if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
05457   return NULL;
05458 }
05459 
05460 
05461 SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05462   PyObject *resultobj = 0;
05463   PLFLT arg1 ;
05464   PLFLT arg2 ;
05465   PLFLT *arg3 = (PLFLT *) 0 ;
05466   PLFLT *arg4 = (PLFLT *) 0 ;
05467   PLINT *arg5 = (PLINT *) 0 ;
05468   double val1 ;
05469   int ecode1 = 0 ;
05470   double val2 ;
05471   int ecode2 = 0 ;
05472   PLFLT temp3 ;
05473   int res3 = SWIG_TMPOBJ ;
05474   PLFLT temp4 ;
05475   int res4 = SWIG_TMPOBJ ;
05476   PLINT temp5 ;
05477   int res5 = SWIG_TMPOBJ ;
05478   PyObject * obj0 = 0 ;
05479   PyObject * obj1 = 0 ;
05480   
05481   arg3 = &temp3;
05482   arg4 = &temp4;
05483   arg5 = &temp5;
05484   if (!PyArg_ParseTuple(args,(char *)"OO:plcalc_world",&obj0,&obj1)) SWIG_fail;
05485   ecode1 = SWIG_AsVal_double(obj0, &val1);
05486   if (!SWIG_IsOK(ecode1)) {
05487     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
05488   } 
05489   arg1 = (PLFLT)(val1);
05490   ecode2 = SWIG_AsVal_double(obj1, &val2);
05491   if (!SWIG_IsOK(ecode2)) {
05492     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
05493   } 
05494   arg2 = (PLFLT)(val2);
05495   plcalc_world(arg1,arg2,arg3,arg4,arg5);
05496   resultobj = SWIG_Py_Void();
05497   if (SWIG_IsTmpObj(res3)) {
05498     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
05499   } else {
05500     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
05501     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
05502   }
05503   if (SWIG_IsTmpObj(res4)) {
05504     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
05505   } else {
05506     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
05507     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
05508   }
05509   if (SWIG_IsTmpObj(res5)) {
05510     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
05511   } else {
05512     int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
05513     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
05514   }
05515   return resultobj;
05516 fail:
05517   return NULL;
05518 }
05519 
05520 
05521 SWIGINTERN PyObject *_wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05522   PyObject *resultobj = 0;
05523   
05524   if (!PyArg_ParseTuple(args,(char *)":plclear")) SWIG_fail;
05525   plclear();
05526   resultobj = SWIG_Py_Void();
05527   return resultobj;
05528 fail:
05529   return NULL;
05530 }
05531 
05532 
05533 SWIGINTERN PyObject *_wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05534   PyObject *resultobj = 0;
05535   PLINT arg1 ;
05536   int val1 ;
05537   int ecode1 = 0 ;
05538   PyObject * obj0 = 0 ;
05539   
05540   if (!PyArg_ParseTuple(args,(char *)"O:plcol0",&obj0)) SWIG_fail;
05541   ecode1 = SWIG_AsVal_int(obj0, &val1);
05542   if (!SWIG_IsOK(ecode1)) {
05543     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
05544   } 
05545   arg1 = (PLINT)(val1);
05546   plcol0(arg1);
05547   resultobj = SWIG_Py_Void();
05548   return resultobj;
05549 fail:
05550   return NULL;
05551 }
05552 
05553 
05554 SWIGINTERN PyObject *_wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05555   PyObject *resultobj = 0;
05556   PLFLT arg1 ;
05557   double val1 ;
05558   int ecode1 = 0 ;
05559   PyObject * obj0 = 0 ;
05560   
05561   if (!PyArg_ParseTuple(args,(char *)"O:plcol1",&obj0)) SWIG_fail;
05562   ecode1 = SWIG_AsVal_double(obj0, &val1);
05563   if (!SWIG_IsOK(ecode1)) {
05564     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
05565   } 
05566   arg1 = (PLFLT)(val1);
05567   plcol1(arg1);
05568   resultobj = SWIG_Py_Void();
05569   return resultobj;
05570 fail:
05571   return NULL;
05572 }
05573 
05574 
05575 SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05576   PyObject *resultobj = 0;
05577   PLFLT arg1 ;
05578   PLFLT arg2 ;
05579   PLFLT arg3 ;
05580   PLINT arg4 ;
05581   PLBOOL arg5 ;
05582   PLINT arg6 ;
05583   PLINT arg7 ;
05584   PLINT arg8 ;
05585   PLINT arg9 ;
05586   PLINT arg10 ;
05587   PLFLT arg11 ;
05588   double val1 ;
05589   int ecode1 = 0 ;
05590   double val2 ;
05591   int ecode2 = 0 ;
05592   double val3 ;
05593   int ecode3 = 0 ;
05594   int val4 ;
05595   int ecode4 = 0 ;
05596   int val5 ;
05597   int ecode5 = 0 ;
05598   int val6 ;
05599   int ecode6 = 0 ;
05600   int val7 ;
05601   int ecode7 = 0 ;
05602   int val8 ;
05603   int ecode8 = 0 ;
05604   int val9 ;
05605   int ecode9 = 0 ;
05606   int val10 ;
05607   int ecode10 = 0 ;
05608   double val11 ;
05609   int ecode11 = 0 ;
05610   PyObject * obj0 = 0 ;
05611   PyObject * obj1 = 0 ;
05612   PyObject * obj2 = 0 ;
05613   PyObject * obj3 = 0 ;
05614   PyObject * obj4 = 0 ;
05615   PyObject * obj5 = 0 ;
05616   PyObject * obj6 = 0 ;
05617   PyObject * obj7 = 0 ;
05618   PyObject * obj8 = 0 ;
05619   PyObject * obj9 = 0 ;
05620   PyObject * obj10 = 0 ;
05621   
05622   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plconfigtime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
05623   ecode1 = SWIG_AsVal_double(obj0, &val1);
05624   if (!SWIG_IsOK(ecode1)) {
05625     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
05626   } 
05627   arg1 = (PLFLT)(val1);
05628   ecode2 = SWIG_AsVal_double(obj1, &val2);
05629   if (!SWIG_IsOK(ecode2)) {
05630     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
05631   } 
05632   arg2 = (PLFLT)(val2);
05633   ecode3 = SWIG_AsVal_double(obj2, &val3);
05634   if (!SWIG_IsOK(ecode3)) {
05635     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
05636   } 
05637   arg3 = (PLFLT)(val3);
05638   ecode4 = SWIG_AsVal_int(obj3, &val4);
05639   if (!SWIG_IsOK(ecode4)) {
05640     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
05641   } 
05642   arg4 = (PLINT)(val4);
05643   ecode5 = SWIG_AsVal_int(obj4, &val5);
05644   if (!SWIG_IsOK(ecode5)) {
05645     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
05646   } 
05647   arg5 = (PLBOOL)(val5);
05648   ecode6 = SWIG_AsVal_int(obj5, &val6);
05649   if (!SWIG_IsOK(ecode6)) {
05650     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
05651   } 
05652   arg6 = (PLINT)(val6);
05653   ecode7 = SWIG_AsVal_int(obj6, &val7);
05654   if (!SWIG_IsOK(ecode7)) {
05655     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
05656   } 
05657   arg7 = (PLINT)(val7);
05658   ecode8 = SWIG_AsVal_int(obj7, &val8);
05659   if (!SWIG_IsOK(ecode8)) {
05660     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
05661   } 
05662   arg8 = (PLINT)(val8);
05663   ecode9 = SWIG_AsVal_int(obj8, &val9);
05664   if (!SWIG_IsOK(ecode9)) {
05665     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
05666   } 
05667   arg9 = (PLINT)(val9);
05668   ecode10 = SWIG_AsVal_int(obj9, &val10);
05669   if (!SWIG_IsOK(ecode10)) {
05670     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
05671   } 
05672   arg10 = (PLINT)(val10);
05673   ecode11 = SWIG_AsVal_double(obj10, &val11);
05674   if (!SWIG_IsOK(ecode11)) {
05675     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
05676   } 
05677   arg11 = (PLFLT)(val11);
05678   plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
05679   resultobj = SWIG_Py_Void();
05680   return resultobj;
05681 fail:
05682   return NULL;
05683 }
05684 
05685 
05686 SWIGINTERN PyObject *_wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05687   PyObject *resultobj = 0;
05688   PLFLT **arg1 = (PLFLT **) 0 ;
05689   PLINT arg2 ;
05690   PLINT arg3 ;
05691   PLINT arg4 ;
05692   PLINT arg5 ;
05693   PLINT arg6 ;
05694   PLINT arg7 ;
05695   PLFLT *arg8 = (PLFLT *) 0 ;
05696   PLINT arg9 ;
05697   pltr_func arg10 = (pltr_func) 0 ;
05698   PLPointer arg11 = (PLPointer) 0 ;
05699   PyArrayObject *tmp1 = NULL ;
05700   int val4 ;
05701   int ecode4 = 0 ;
05702   int val5 ;
05703   int ecode5 = 0 ;
05704   int val6 ;
05705   int ecode6 = 0 ;
05706   int val7 ;
05707   int ecode7 = 0 ;
05708   PyArrayObject *tmp8 = NULL ;
05709   PyObject * obj0 = 0 ;
05710   PyObject * obj1 = 0 ;
05711   PyObject * obj2 = 0 ;
05712   PyObject * obj3 = 0 ;
05713   PyObject * obj4 = 0 ;
05714   PyObject * obj5 = 0 ;
05715   PyObject * obj6 = 0 ;
05716   PyObject * obj7 = 0 ;
05717   
05718   {
05719     python_pltr = 0;
05720     arg10          = NULL;
05721   }
05722   {
05723     arg11 = NULL;
05724   }
05725   if (!PyArg_ParseTuple(args,(char *)"OOOOOO|OO:plcont",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
05726   {
05727     int i, size;
05728     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
05729     if ( tmp1 == NULL )
05730     return NULL;
05731     Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
05732     Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
05733     size = arg3;
05734     arg1   = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
05735     for ( i = 0; i < arg2; i++ )
05736     arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
05737   }
05738   ecode4 = SWIG_AsVal_int(obj1, &val4);
05739   if (!SWIG_IsOK(ecode4)) {
05740     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
05741   } 
05742   arg4 = (PLINT)(val4);
05743   ecode5 = SWIG_AsVal_int(obj2, &val5);
05744   if (!SWIG_IsOK(ecode5)) {
05745     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
05746   } 
05747   arg5 = (PLINT)(val5);
05748   ecode6 = SWIG_AsVal_int(obj3, &val6);
05749   if (!SWIG_IsOK(ecode6)) {
05750     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
05751   } 
05752   arg6 = (PLINT)(val6);
05753   ecode7 = SWIG_AsVal_int(obj4, &val7);
05754   if (!SWIG_IsOK(ecode7)) {
05755     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
05756   } 
05757   arg7 = (PLINT)(val7);
05758   {
05759     tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
05760     if ( tmp8 == NULL )
05761     return NULL;
05762     arg9 = PyArray_DIMS( tmp8 )[0];
05763     arg8 = (PLFLT *) PyArray_DATA( tmp8 );
05764   }
05765   if (obj6) {
05766     {
05767       // it must be a callable or None
05768       if ( obj6 == Py_None )
05769       {
05770         arg10 = NULL;
05771       }
05772       else
05773       {
05774         if ( !PyCallable_Check( (PyObject *) obj6 ) )
05775         {
05776           PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
05777           return NULL;
05778         }
05779         arg10 = marshal_pltr( obj6 );
05780       }
05781     }
05782   }
05783   if (obj7) {
05784     {
05785       if ( obj7 == Py_None )
05786       arg11 = NULL;
05787       else
05788       {
05789         arg11 = marshal_PLPointer( obj7, 0 );
05790       }
05791     }
05792   }
05793   plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
05794   resultobj = SWIG_Py_Void();
05795   {
05796     Py_CLEAR( tmp1 );
05797     free( arg1 );
05798   }
05799   {
05800     Py_CLEAR( tmp8 );
05801   }
05802   {
05803     cleanup_pltr();
05804   }
05805   {
05806     cleanup_PLPointer();
05807   }
05808   return resultobj;
05809 fail:
05810   {
05811     Py_CLEAR( tmp1 );
05812     free( arg1 );
05813   }
05814   {
05815     Py_CLEAR( tmp8 );
05816   }
05817   {
05818     cleanup_pltr();
05819   }
05820   {
05821     cleanup_PLPointer();
05822   }
05823   return NULL;
05824 }
05825 
05826 
05827 SWIGINTERN PyObject *_wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05828   PyObject *resultobj = 0;
05829   PLINT arg1 ;
05830   PLINT arg2 ;
05831   PLINT arg3 ;
05832   PLINT arg4 ;
05833   PLINT arg5 ;
05834   PLFLT arg6 ;
05835   PLFLT *arg7 = (PLFLT *) 0 ;
05836   int val1 ;
05837   int ecode1 = 0 ;
05838   int val2 ;
05839   int ecode2 = 0 ;
05840   int val3 ;
05841   int ecode3 = 0 ;
05842   int val4 ;
05843   int ecode4 = 0 ;
05844   int val5 ;
05845   int ecode5 = 0 ;
05846   double val6 ;
05847   int ecode6 = 0 ;
05848   PLFLT temp7 ;
05849   int res7 = SWIG_TMPOBJ ;
05850   PyObject * obj0 = 0 ;
05851   PyObject * obj1 = 0 ;
05852   PyObject * obj2 = 0 ;
05853   PyObject * obj3 = 0 ;
05854   PyObject * obj4 = 0 ;
05855   PyObject * obj5 = 0 ;
05856   
05857   arg7 = &temp7;
05858   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plctime",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
05859   ecode1 = SWIG_AsVal_int(obj0, &val1);
05860   if (!SWIG_IsOK(ecode1)) {
05861     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
05862   } 
05863   arg1 = (PLINT)(val1);
05864   ecode2 = SWIG_AsVal_int(obj1, &val2);
05865   if (!SWIG_IsOK(ecode2)) {
05866     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
05867   } 
05868   arg2 = (PLINT)(val2);
05869   ecode3 = SWIG_AsVal_int(obj2, &val3);
05870   if (!SWIG_IsOK(ecode3)) {
05871     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
05872   } 
05873   arg3 = (PLINT)(val3);
05874   ecode4 = SWIG_AsVal_int(obj3, &val4);
05875   if (!SWIG_IsOK(ecode4)) {
05876     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
05877   } 
05878   arg4 = (PLINT)(val4);
05879   ecode5 = SWIG_AsVal_int(obj4, &val5);
05880   if (!SWIG_IsOK(ecode5)) {
05881     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
05882   } 
05883   arg5 = (PLINT)(val5);
05884   ecode6 = SWIG_AsVal_double(obj5, &val6);
05885   if (!SWIG_IsOK(ecode6)) {
05886     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
05887   } 
05888   arg6 = (PLFLT)(val6);
05889   plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
05890   resultobj = SWIG_Py_Void();
05891   if (SWIG_IsTmpObj(res7)) {
05892     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
05893   } else {
05894     int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
05895     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
05896   }
05897   return resultobj;
05898 fail:
05899   return NULL;
05900 }
05901 
05902 
05903 SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05904   PyObject *resultobj = 0;
05905   PLINT arg1 ;
05906   PLBOOL arg2 ;
05907   int val1 ;
05908   int ecode1 = 0 ;
05909   int val2 ;
05910   int ecode2 = 0 ;
05911   PyObject * obj0 = 0 ;
05912   PyObject * obj1 = 0 ;
05913   
05914   if (!PyArg_ParseTuple(args,(char *)"OO:plcpstrm",&obj0,&obj1)) SWIG_fail;
05915   ecode1 = SWIG_AsVal_int(obj0, &val1);
05916   if (!SWIG_IsOK(ecode1)) {
05917     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
05918   } 
05919   arg1 = (PLINT)(val1);
05920   ecode2 = SWIG_AsVal_int(obj1, &val2);
05921   if (!SWIG_IsOK(ecode2)) {
05922     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
05923   } 
05924   arg2 = (PLBOOL)(val2);
05925   plcpstrm(arg1,arg2);
05926   resultobj = SWIG_Py_Void();
05927   return resultobj;
05928 fail:
05929   return NULL;
05930 }
05931 
05932 
05933 SWIGINTERN PyObject *_wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05934   PyObject *resultobj = 0;
05935   
05936   if (!PyArg_ParseTuple(args,(char *)":plend")) SWIG_fail;
05937   plend();
05938   resultobj = SWIG_Py_Void();
05939   return resultobj;
05940 fail:
05941   return NULL;
05942 }
05943 
05944 
05945 SWIGINTERN PyObject *_wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05946   PyObject *resultobj = 0;
05947   
05948   if (!PyArg_ParseTuple(args,(char *)":plend1")) SWIG_fail;
05949   plend1();
05950   resultobj = SWIG_Py_Void();
05951   return resultobj;
05952 fail:
05953   return NULL;
05954 }
05955 
05956 
05957 SWIGINTERN PyObject *_wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05958   PyObject *resultobj = 0;
05959   PLFLT arg1 ;
05960   PLFLT arg2 ;
05961   PLFLT arg3 ;
05962   PLFLT arg4 ;
05963   PLINT arg5 ;
05964   PLINT arg6 ;
05965   double val1 ;
05966   int ecode1 = 0 ;
05967   double val2 ;
05968   int ecode2 = 0 ;
05969   double val3 ;
05970   int ecode3 = 0 ;
05971   double val4 ;
05972   int ecode4 = 0 ;
05973   int val5 ;
05974   int ecode5 = 0 ;
05975   int val6 ;
05976   int ecode6 = 0 ;
05977   PyObject * obj0 = 0 ;
05978   PyObject * obj1 = 0 ;
05979   PyObject * obj2 = 0 ;
05980   PyObject * obj3 = 0 ;
05981   PyObject * obj4 = 0 ;
05982   PyObject * obj5 = 0 ;
05983   
05984   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
05985   ecode1 = SWIG_AsVal_double(obj0, &val1);
05986   if (!SWIG_IsOK(ecode1)) {
05987     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
05988   } 
05989   arg1 = (PLFLT)(val1);
05990   ecode2 = SWIG_AsVal_double(obj1, &val2);
05991   if (!SWIG_IsOK(ecode2)) {
05992     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
05993   } 
05994   arg2 = (PLFLT)(val2);
05995   ecode3 = SWIG_AsVal_double(obj2, &val3);
05996   if (!SWIG_IsOK(ecode3)) {
05997     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
05998   } 
05999   arg3 = (PLFLT)(val3);
06000   ecode4 = SWIG_AsVal_double(obj3, &val4);
06001   if (!SWIG_IsOK(ecode4)) {
06002     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
06003   } 
06004   arg4 = (PLFLT)(val4);
06005   ecode5 = SWIG_AsVal_int(obj4, &val5);
06006   if (!SWIG_IsOK(ecode5)) {
06007     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
06008   } 
06009   arg5 = (PLINT)(val5);
06010   ecode6 = SWIG_AsVal_int(obj5, &val6);
06011   if (!SWIG_IsOK(ecode6)) {
06012     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
06013   } 
06014   arg6 = (PLINT)(val6);
06015   plenv(arg1,arg2,arg3,arg4,arg5,arg6);
06016   resultobj = SWIG_Py_Void();
06017   return resultobj;
06018 fail:
06019   return NULL;
06020 }
06021 
06022 
06023 SWIGINTERN PyObject *_wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06024   PyObject *resultobj = 0;
06025   PLFLT arg1 ;
06026   PLFLT arg2 ;
06027   PLFLT arg3 ;
06028   PLFLT arg4 ;
06029   PLINT arg5 ;
06030   PLINT arg6 ;
06031   double val1 ;
06032   int ecode1 = 0 ;
06033   double val2 ;
06034   int ecode2 = 0 ;
06035   double val3 ;
06036   int ecode3 = 0 ;
06037   double val4 ;
06038   int ecode4 = 0 ;
06039   int val5 ;
06040   int ecode5 = 0 ;
06041   int val6 ;
06042   int ecode6 = 0 ;
06043   PyObject * obj0 = 0 ;
06044   PyObject * obj1 = 0 ;
06045   PyObject * obj2 = 0 ;
06046   PyObject * obj3 = 0 ;
06047   PyObject * obj4 = 0 ;
06048   PyObject * obj5 = 0 ;
06049   
06050   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plenv0",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
06051   ecode1 = SWIG_AsVal_double(obj0, &val1);
06052   if (!SWIG_IsOK(ecode1)) {
06053     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
06054   } 
06055   arg1 = (PLFLT)(val1);
06056   ecode2 = SWIG_AsVal_double(obj1, &val2);
06057   if (!SWIG_IsOK(ecode2)) {
06058     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
06059   } 
06060   arg2 = (PLFLT)(val2);
06061   ecode3 = SWIG_AsVal_double(obj2, &val3);
06062   if (!SWIG_IsOK(ecode3)) {
06063     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
06064   } 
06065   arg3 = (PLFLT)(val3);
06066   ecode4 = SWIG_AsVal_double(obj3, &val4);
06067   if (!SWIG_IsOK(ecode4)) {
06068     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
06069   } 
06070   arg4 = (PLFLT)(val4);
06071   ecode5 = SWIG_AsVal_int(obj4, &val5);
06072   if (!SWIG_IsOK(ecode5)) {
06073     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
06074   } 
06075   arg5 = (PLINT)(val5);
06076   ecode6 = SWIG_AsVal_int(obj5, &val6);
06077   if (!SWIG_IsOK(ecode6)) {
06078     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
06079   } 
06080   arg6 = (PLINT)(val6);
06081   plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
06082   resultobj = SWIG_Py_Void();
06083   return resultobj;
06084 fail:
06085   return NULL;
06086 }
06087 
06088 
06089 SWIGINTERN PyObject *_wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06090   PyObject *resultobj = 0;
06091   
06092   if (!PyArg_ParseTuple(args,(char *)":pleop")) SWIG_fail;
06093   pleop();
06094   resultobj = SWIG_Py_Void();
06095   return resultobj;
06096 fail:
06097   return NULL;
06098 }
06099 
06100 
06101 SWIGINTERN PyObject *_wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06102   PyObject *resultobj = 0;
06103   PLINT arg1 ;
06104   PLFLT *arg2 = (PLFLT *) 0 ;
06105   PLFLT *arg3 = (PLFLT *) 0 ;
06106   PLFLT *arg4 = (PLFLT *) 0 ;
06107   PyArrayObject *tmp1 = NULL ;
06108   PyArrayObject *tmp3 = NULL ;
06109   PyArrayObject *tmp4 = NULL ;
06110   PyObject * obj0 = 0 ;
06111   PyObject * obj1 = 0 ;
06112   PyObject * obj2 = 0 ;
06113   
06114   if (!PyArg_ParseTuple(args,(char *)"OOO:plerrx",&obj0,&obj1,&obj2)) SWIG_fail;
06115   {
06116     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
06117     if ( tmp1 == NULL )
06118     return NULL;
06119     arg1 = Alen = PyArray_DIMS( tmp1 )[0];
06120     arg2 = (PLFLT *) PyArray_DATA( tmp1 );
06121   }
06122   {
06123     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
06124     if ( tmp3 == NULL )
06125     return NULL;
06126     if ( PyArray_DIMS( tmp3 )[0] != Alen )
06127     {
06128       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
06129       return NULL;
06130     }
06131     arg3 = (PLFLT *) PyArray_DATA( tmp3 );
06132   }
06133   {
06134     tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
06135     if ( tmp4 == NULL )
06136     return NULL;
06137     if ( PyArray_DIMS( tmp4 )[0] != Alen )
06138     {
06139       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
06140       return NULL;
06141     }
06142     arg4 = (PLFLT *) PyArray_DATA( tmp4 );
06143   }
06144   plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
06145   resultobj = SWIG_Py_Void();
06146   {
06147     Py_CLEAR( tmp1 );
06148   }
06149   {
06150     Py_CLEAR( tmp3 );
06151   }
06152   {
06153     Py_CLEAR( tmp4 );
06154   }
06155   return resultobj;
06156 fail:
06157   {
06158     Py_CLEAR( tmp1 );
06159   }
06160   {
06161     Py_CLEAR( tmp3 );
06162   }
06163   {
06164     Py_CLEAR( tmp4 );
06165   }
06166   return NULL;
06167 }
06168 
06169 
06170 SWIGINTERN PyObject *_wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06171   PyObject *resultobj = 0;
06172   PLINT arg1 ;
06173   PLFLT *arg2 = (PLFLT *) 0 ;
06174   PLFLT *arg3 = (PLFLT *) 0 ;
06175   PLFLT *arg4 = (PLFLT *) 0 ;
06176   PyArrayObject *tmp1 = NULL ;
06177   PyArrayObject *tmp3 = NULL ;
06178   PyArrayObject *tmp4 = NULL ;
06179   PyObject * obj0 = 0 ;
06180   PyObject * obj1 = 0 ;
06181   PyObject * obj2 = 0 ;
06182   
06183   if (!PyArg_ParseTuple(args,(char *)"OOO:plerry",&obj0,&obj1,&obj2)) SWIG_fail;
06184   {
06185     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
06186     if ( tmp1 == NULL )
06187     return NULL;
06188     arg1 = Alen = PyArray_DIMS( tmp1 )[0];
06189     arg2 = (PLFLT *) PyArray_DATA( tmp1 );
06190   }
06191   {
06192     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
06193     if ( tmp3 == NULL )
06194     return NULL;
06195     if ( PyArray_DIMS( tmp3 )[0] != Alen )
06196     {
06197       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
06198       return NULL;
06199     }
06200     arg3 = (PLFLT *) PyArray_DATA( tmp3 );
06201   }
06202   {
06203     tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
06204     if ( tmp4 == NULL )
06205     return NULL;
06206     if ( PyArray_DIMS( tmp4 )[0] != Alen )
06207     {
06208       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
06209       return NULL;
06210     }
06211     arg4 = (PLFLT *) PyArray_DATA( tmp4 );
06212   }
06213   plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
06214   resultobj = SWIG_Py_Void();
06215   {
06216     Py_CLEAR( tmp1 );
06217   }
06218   {
06219     Py_CLEAR( tmp3 );
06220   }
06221   {
06222     Py_CLEAR( tmp4 );
06223   }
06224   return resultobj;
06225 fail:
06226   {
06227     Py_CLEAR( tmp1 );
06228   }
06229   {
06230     Py_CLEAR( tmp3 );
06231   }
06232   {
06233     Py_CLEAR( tmp4 );
06234   }
06235   return NULL;
06236 }
06237 
06238 
06239 SWIGINTERN PyObject *_wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06240   PyObject *resultobj = 0;
06241   
06242   if (!PyArg_ParseTuple(args,(char *)":plfamadv")) SWIG_fail;
06243   plfamadv();
06244   resultobj = SWIG_Py_Void();
06245   return resultobj;
06246 fail:
06247   return NULL;
06248 }
06249 
06250 
06251 SWIGINTERN PyObject *_wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06252   PyObject *resultobj = 0;
06253   PLINT arg1 ;
06254   PLFLT *arg2 = (PLFLT *) 0 ;
06255   PLFLT *arg3 = (PLFLT *) 0 ;
06256   PyArrayObject *tmp1 = NULL ;
06257   PyArrayObject *tmp3 = NULL ;
06258   PyObject * obj0 = 0 ;
06259   PyObject * obj1 = 0 ;
06260   
06261   if (!PyArg_ParseTuple(args,(char *)"OO:plfill",&obj0,&obj1)) SWIG_fail;
06262   {
06263     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
06264     if ( tmp1 == NULL )
06265     return NULL;
06266     arg1 = Alen = PyArray_DIMS( tmp1 )[0];
06267     arg2 = (PLFLT *) PyArray_DATA( tmp1 );
06268   }
06269   {
06270     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
06271     if ( tmp3 == NULL )
06272     return NULL;
06273     if ( PyArray_DIMS( tmp3 )[0] != Alen )
06274     {
06275       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
06276       return NULL;
06277     }
06278     arg3 = (PLFLT *) PyArray_DATA( tmp3 );
06279   }
06280   plfill(arg1,(double const *)arg2,(double const *)arg3);
06281   resultobj = SWIG_Py_Void();
06282   {
06283     Py_CLEAR( tmp1 );
06284   }
06285   {
06286     Py_CLEAR( tmp3 );
06287   }
06288   return resultobj;
06289 fail:
06290   {
06291     Py_CLEAR( tmp1 );
06292   }
06293   {
06294     Py_CLEAR( tmp3 );
06295   }
06296   return NULL;
06297 }
06298 
06299 
06300 SWIGINTERN PyObject *_wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06301   PyObject *resultobj = 0;
06302   PLINT arg1 ;
06303   PLFLT *arg2 = (PLFLT *) 0 ;
06304   PLFLT *arg3 = (PLFLT *) 0 ;
06305   PLFLT *arg4 = (PLFLT *) 0 ;
06306   PyArrayObject *tmp1 = NULL ;
06307   PyArrayObject *tmp3 = NULL ;
06308   PyArrayObject *tmp4 = NULL ;
06309   PyObject * obj0 = 0 ;
06310   PyObject * obj1 = 0 ;
06311   PyObject * obj2 = 0 ;
06312   
06313   if (!PyArg_ParseTuple(args,(char *)"OOO:plfill3",&obj0,&obj1,&obj2)) SWIG_fail;
06314   {
06315     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
06316     if ( tmp1 == NULL )
06317     return NULL;
06318     arg1 = Alen = PyArray_DIMS( tmp1 )[0];
06319     arg2 = (PLFLT *) PyArray_DATA( tmp1 );
06320   }
06321   {
06322     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
06323     if ( tmp3 == NULL )
06324     return NULL;
06325     if ( PyArray_DIMS( tmp3 )[0] != Alen )
06326     {
06327       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
06328       return NULL;
06329     }
06330     arg3 = (PLFLT *) PyArray_DATA( tmp3 );
06331   }
06332   {
06333     tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
06334     if ( tmp4 == NULL )
06335     return NULL;
06336     if ( PyArray_DIMS( tmp4 )[0] != Alen )
06337     {
06338       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
06339       return NULL;
06340     }
06341     arg4 = (PLFLT *) PyArray_DATA( tmp4 );
06342   }
06343   plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
06344   resultobj = SWIG_Py_Void();
06345   {
06346     Py_CLEAR( tmp1 );
06347   }
06348   {
06349     Py_CLEAR( tmp3 );
06350   }
06351   {
06352     Py_CLEAR( tmp4 );
06353   }
06354   return resultobj;
06355 fail:
06356   {
06357     Py_CLEAR( tmp1 );
06358   }
06359   {
06360     Py_CLEAR( tmp3 );
06361   }
06362   {
06363     Py_CLEAR( tmp4 );
06364   }
06365   return NULL;
06366 }
06367 
06368 
06369 SWIGINTERN PyObject *_wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06370   PyObject *resultobj = 0;
06371   PLINT arg1 ;
06372   PLFLT *arg2 = (PLFLT *) 0 ;
06373   PLFLT *arg3 = (PLFLT *) 0 ;
06374   PLFLT arg4 ;
06375   PyArrayObject *tmp1 = NULL ;
06376   PyArrayObject *tmp3 = NULL ;
06377   double val4 ;
06378   int ecode4 = 0 ;
06379   PyObject * obj0 = 0 ;
06380   PyObject * obj1 = 0 ;
06381   PyObject * obj2 = 0 ;
06382   
06383   if (!PyArg_ParseTuple(args,(char *)"OOO:plgradient",&obj0,&obj1,&obj2)) SWIG_fail;
06384   {
06385     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
06386     if ( tmp1 == NULL )
06387     return NULL;
06388     arg1 = Alen = PyArray_DIMS( tmp1 )[0];
06389     arg2 = (PLFLT *) PyArray_DATA( tmp1 );
06390   }
06391   {
06392     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
06393     if ( tmp3 == NULL )
06394     return NULL;
06395     if ( PyArray_DIMS( tmp3 )[0] != Alen )
06396     {
06397       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
06398       return NULL;
06399     }
06400     arg3 = (PLFLT *) PyArray_DATA( tmp3 );
06401   }
06402   ecode4 = SWIG_AsVal_double(obj2, &val4);
06403   if (!SWIG_IsOK(ecode4)) {
06404     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
06405   } 
06406   arg4 = (PLFLT)(val4);
06407   plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
06408   resultobj = SWIG_Py_Void();
06409   {
06410     Py_CLEAR( tmp1 );
06411   }
06412   {
06413     Py_CLEAR( tmp3 );
06414   }
06415   return resultobj;
06416 fail:
06417   {
06418     Py_CLEAR( tmp1 );
06419   }
06420   {
06421     Py_CLEAR( tmp3 );
06422   }
06423   return NULL;
06424 }
06425 
06426 
06427 SWIGINTERN PyObject *_wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06428   PyObject *resultobj = 0;
06429   
06430   if (!PyArg_ParseTuple(args,(char *)":plflush")) SWIG_fail;
06431   plflush();
06432   resultobj = SWIG_Py_Void();
06433   return resultobj;
06434 fail:
06435   return NULL;
06436 }
06437 
06438 
06439 SWIGINTERN PyObject *_wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06440   PyObject *resultobj = 0;
06441   PLINT arg1 ;
06442   int val1 ;
06443   int ecode1 = 0 ;
06444   PyObject * obj0 = 0 ;
06445   
06446   if (!PyArg_ParseTuple(args,(char *)"O:plfont",&obj0)) SWIG_fail;
06447   ecode1 = SWIG_AsVal_int(obj0, &val1);
06448   if (!SWIG_IsOK(ecode1)) {
06449     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
06450   } 
06451   arg1 = (PLINT)(val1);
06452   plfont(arg1);
06453   resultobj = SWIG_Py_Void();
06454   return resultobj;
06455 fail:
06456   return NULL;
06457 }
06458 
06459 
06460 SWIGINTERN PyObject *_wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06461   PyObject *resultobj = 0;
06462   PLINT arg1 ;
06463   int val1 ;
06464   int ecode1 = 0 ;
06465   PyObject * obj0 = 0 ;
06466   
06467   if (!PyArg_ParseTuple(args,(char *)"O:plfontld",&obj0)) SWIG_fail;
06468   ecode1 = SWIG_AsVal_int(obj0, &val1);
06469   if (!SWIG_IsOK(ecode1)) {
06470     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
06471   } 
06472   arg1 = (PLINT)(val1);
06473   plfontld(arg1);
06474   resultobj = SWIG_Py_Void();
06475   return resultobj;
06476 fail:
06477   return NULL;
06478 }
06479 
06480 
06481 SWIGINTERN PyObject *_wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06482   PyObject *resultobj = 0;
06483   PLFLT *arg1 = (PLFLT *) 0 ;
06484   PLFLT *arg2 = (PLFLT *) 0 ;
06485   PLFLT temp1 ;
06486   int res1 = SWIG_TMPOBJ ;
06487   PLFLT temp2 ;
06488   int res2 = SWIG_TMPOBJ ;
06489   
06490   arg1 = &temp1;
06491   arg2 = &temp2;
06492   if (!PyArg_ParseTuple(args,(char *)":plgchr")) SWIG_fail;
06493   plgchr(arg1,arg2);
06494   resultobj = SWIG_Py_Void();
06495   if (SWIG_IsTmpObj(res1)) {
06496     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
06497   } else {
06498     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06499     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
06500   }
06501   if (SWIG_IsTmpObj(res2)) {
06502     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
06503   } else {
06504     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06505     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
06506   }
06507   return resultobj;
06508 fail:
06509   return NULL;
06510 }
06511 
06512 
06513 SWIGINTERN PyObject *_wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06514   PyObject *resultobj = 0;
06515   PLINT arg1 ;
06516   PLINT *arg2 = (PLINT *) 0 ;
06517   PLINT *arg3 = (PLINT *) 0 ;
06518   PLINT *arg4 = (PLINT *) 0 ;
06519   int val1 ;
06520   int ecode1 = 0 ;
06521   PLINT temp2 ;
06522   int res2 = SWIG_TMPOBJ ;
06523   PLINT temp3 ;
06524   int res3 = SWIG_TMPOBJ ;
06525   PLINT temp4 ;
06526   int res4 = SWIG_TMPOBJ ;
06527   PyObject * obj0 = 0 ;
06528   
06529   arg2 = &temp2;
06530   arg3 = &temp3;
06531   arg4 = &temp4;
06532   if (!PyArg_ParseTuple(args,(char *)"O:plgcol0",&obj0)) SWIG_fail;
06533   ecode1 = SWIG_AsVal_int(obj0, &val1);
06534   if (!SWIG_IsOK(ecode1)) {
06535     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
06536   } 
06537   arg1 = (PLINT)(val1);
06538   plgcol0(arg1,arg2,arg3,arg4);
06539   resultobj = SWIG_Py_Void();
06540   if (SWIG_IsTmpObj(res2)) {
06541     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
06542   } else {
06543     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06544     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
06545   }
06546   if (SWIG_IsTmpObj(res3)) {
06547     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
06548   } else {
06549     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06550     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
06551   }
06552   if (SWIG_IsTmpObj(res4)) {
06553     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
06554   } else {
06555     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06556     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
06557   }
06558   return resultobj;
06559 fail:
06560   return NULL;
06561 }
06562 
06563 
06564 SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06565   PyObject *resultobj = 0;
06566   PLINT arg1 ;
06567   PLINT *arg2 = (PLINT *) 0 ;
06568   PLINT *arg3 = (PLINT *) 0 ;
06569   PLINT *arg4 = (PLINT *) 0 ;
06570   PLFLT *arg5 = (PLFLT *) 0 ;
06571   int val1 ;
06572   int ecode1 = 0 ;
06573   PLINT temp2 ;
06574   int res2 = SWIG_TMPOBJ ;
06575   PLINT temp3 ;
06576   int res3 = SWIG_TMPOBJ ;
06577   PLINT temp4 ;
06578   int res4 = SWIG_TMPOBJ ;
06579   PLFLT temp5 ;
06580   int res5 = SWIG_TMPOBJ ;
06581   PyObject * obj0 = 0 ;
06582   
06583   arg2 = &temp2;
06584   arg3 = &temp3;
06585   arg4 = &temp4;
06586   arg5 = &temp5;
06587   if (!PyArg_ParseTuple(args,(char *)"O:plgcol0a",&obj0)) SWIG_fail;
06588   ecode1 = SWIG_AsVal_int(obj0, &val1);
06589   if (!SWIG_IsOK(ecode1)) {
06590     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
06591   } 
06592   arg1 = (PLINT)(val1);
06593   plgcol0a(arg1,arg2,arg3,arg4,arg5);
06594   resultobj = SWIG_Py_Void();
06595   if (SWIG_IsTmpObj(res2)) {
06596     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
06597   } else {
06598     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06599     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
06600   }
06601   if (SWIG_IsTmpObj(res3)) {
06602     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
06603   } else {
06604     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06605     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
06606   }
06607   if (SWIG_IsTmpObj(res4)) {
06608     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
06609   } else {
06610     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06611     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
06612   }
06613   if (SWIG_IsTmpObj(res5)) {
06614     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
06615   } else {
06616     int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06617     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
06618   }
06619   return resultobj;
06620 fail:
06621   return NULL;
06622 }
06623 
06624 
06625 SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06626   PyObject *resultobj = 0;
06627   PLINT *arg1 = (PLINT *) 0 ;
06628   PLINT *arg2 = (PLINT *) 0 ;
06629   PLINT *arg3 = (PLINT *) 0 ;
06630   PLINT temp1 ;
06631   int res1 = SWIG_TMPOBJ ;
06632   PLINT temp2 ;
06633   int res2 = SWIG_TMPOBJ ;
06634   PLINT temp3 ;
06635   int res3 = SWIG_TMPOBJ ;
06636   
06637   arg1 = &temp1;
06638   arg2 = &temp2;
06639   arg3 = &temp3;
06640   if (!PyArg_ParseTuple(args,(char *)":plgcolbg")) SWIG_fail;
06641   plgcolbg(arg1,arg2,arg3);
06642   resultobj = SWIG_Py_Void();
06643   if (SWIG_IsTmpObj(res1)) {
06644     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
06645   } else {
06646     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06647     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
06648   }
06649   if (SWIG_IsTmpObj(res2)) {
06650     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
06651   } else {
06652     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06653     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
06654   }
06655   if (SWIG_IsTmpObj(res3)) {
06656     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
06657   } else {
06658     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06659     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
06660   }
06661   return resultobj;
06662 fail:
06663   return NULL;
06664 }
06665 
06666 
06667 SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06668   PyObject *resultobj = 0;
06669   PLINT *arg1 = (PLINT *) 0 ;
06670   PLINT *arg2 = (PLINT *) 0 ;
06671   PLINT *arg3 = (PLINT *) 0 ;
06672   PLFLT *arg4 = (PLFLT *) 0 ;
06673   PLINT temp1 ;
06674   int res1 = SWIG_TMPOBJ ;
06675   PLINT temp2 ;
06676   int res2 = SWIG_TMPOBJ ;
06677   PLINT temp3 ;
06678   int res3 = SWIG_TMPOBJ ;
06679   PLFLT temp4 ;
06680   int res4 = SWIG_TMPOBJ ;
06681   
06682   arg1 = &temp1;
06683   arg2 = &temp2;
06684   arg3 = &temp3;
06685   arg4 = &temp4;
06686   if (!PyArg_ParseTuple(args,(char *)":plgcolbga")) SWIG_fail;
06687   plgcolbga(arg1,arg2,arg3,arg4);
06688   resultobj = SWIG_Py_Void();
06689   if (SWIG_IsTmpObj(res1)) {
06690     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
06691   } else {
06692     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06693     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
06694   }
06695   if (SWIG_IsTmpObj(res2)) {
06696     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
06697   } else {
06698     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06699     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
06700   }
06701   if (SWIG_IsTmpObj(res3)) {
06702     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
06703   } else {
06704     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06705     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
06706   }
06707   if (SWIG_IsTmpObj(res4)) {
06708     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
06709   } else {
06710     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06711     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
06712   }
06713   return resultobj;
06714 fail:
06715   return NULL;
06716 }
06717 
06718 
06719 SWIGINTERN PyObject *_wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06720   PyObject *resultobj = 0;
06721   PLINT *arg1 = (PLINT *) 0 ;
06722   PLINT temp1 ;
06723   int res1 = SWIG_TMPOBJ ;
06724   
06725   arg1 = &temp1;
06726   if (!PyArg_ParseTuple(args,(char *)":plgcompression")) SWIG_fail;
06727   plgcompression(arg1);
06728   resultobj = SWIG_Py_Void();
06729   if (SWIG_IsTmpObj(res1)) {
06730     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
06731   } else {
06732     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06733     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
06734   }
06735   return resultobj;
06736 fail:
06737   return NULL;
06738 }
06739 
06740 
06741 SWIGINTERN PyObject *_wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06742   PyObject *resultobj = 0;
06743   char *arg1 = (char *) 0 ;
06744   char buff1[1000] ;
06745   
06746   {
06747     arg1 = buff1;
06748   }
06749   if (!PyArg_ParseTuple(args,(char *)":plgdev")) SWIG_fail;
06750   plgdev(arg1);
06751   resultobj = SWIG_Py_Void();
06752   {
06753     PyObject *o = PyString_FromString( arg1 );
06754     resultobj = t_output_helper( resultobj, o );
06755   }
06756   return resultobj;
06757 fail:
06758   return NULL;
06759 }
06760 
06761 
06762 SWIGINTERN PyObject *_wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06763   PyObject *resultobj = 0;
06764   PLFLT *arg1 = (PLFLT *) 0 ;
06765   PLFLT *arg2 = (PLFLT *) 0 ;
06766   PLFLT *arg3 = (PLFLT *) 0 ;
06767   PLFLT *arg4 = (PLFLT *) 0 ;
06768   PLFLT temp1 ;
06769   int res1 = SWIG_TMPOBJ ;
06770   PLFLT temp2 ;
06771   int res2 = SWIG_TMPOBJ ;
06772   PLFLT temp3 ;
06773   int res3 = SWIG_TMPOBJ ;
06774   PLFLT temp4 ;
06775   int res4 = SWIG_TMPOBJ ;
06776   
06777   arg1 = &temp1;
06778   arg2 = &temp2;
06779   arg3 = &temp3;
06780   arg4 = &temp4;
06781   if (!PyArg_ParseTuple(args,(char *)":plgdidev")) SWIG_fail;
06782   plgdidev(arg1,arg2,arg3,arg4);
06783   resultobj = SWIG_Py_Void();
06784   if (SWIG_IsTmpObj(res1)) {
06785     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
06786   } else {
06787     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06788     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
06789   }
06790   if (SWIG_IsTmpObj(res2)) {
06791     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
06792   } else {
06793     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06794     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
06795   }
06796   if (SWIG_IsTmpObj(res3)) {
06797     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
06798   } else {
06799     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06800     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
06801   }
06802   if (SWIG_IsTmpObj(res4)) {
06803     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
06804   } else {
06805     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06806     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
06807   }
06808   return resultobj;
06809 fail:
06810   return NULL;
06811 }
06812 
06813 
06814 SWIGINTERN PyObject *_wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06815   PyObject *resultobj = 0;
06816   PLFLT *arg1 = (PLFLT *) 0 ;
06817   PLFLT temp1 ;
06818   int res1 = SWIG_TMPOBJ ;
06819   
06820   arg1 = &temp1;
06821   if (!PyArg_ParseTuple(args,(char *)":plgdiori")) SWIG_fail;
06822   plgdiori(arg1);
06823   resultobj = SWIG_Py_Void();
06824   if (SWIG_IsTmpObj(res1)) {
06825     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
06826   } else {
06827     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06828     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
06829   }
06830   return resultobj;
06831 fail:
06832   return NULL;
06833 }
06834 
06835 
06836 SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06837   PyObject *resultobj = 0;
06838   PLFLT *arg1 = (PLFLT *) 0 ;
06839   PLFLT *arg2 = (PLFLT *) 0 ;
06840   PLFLT *arg3 = (PLFLT *) 0 ;
06841   PLFLT *arg4 = (PLFLT *) 0 ;
06842   PLFLT temp1 ;
06843   int res1 = SWIG_TMPOBJ ;
06844   PLFLT temp2 ;
06845   int res2 = SWIG_TMPOBJ ;
06846   PLFLT temp3 ;
06847   int res3 = SWIG_TMPOBJ ;
06848   PLFLT temp4 ;
06849   int res4 = SWIG_TMPOBJ ;
06850   
06851   arg1 = &temp1;
06852   arg2 = &temp2;
06853   arg3 = &temp3;
06854   arg4 = &temp4;
06855   if (!PyArg_ParseTuple(args,(char *)":plgdiplt")) SWIG_fail;
06856   plgdiplt(arg1,arg2,arg3,arg4);
06857   resultobj = SWIG_Py_Void();
06858   if (SWIG_IsTmpObj(res1)) {
06859     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
06860   } else {
06861     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06862     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
06863   }
06864   if (SWIG_IsTmpObj(res2)) {
06865     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
06866   } else {
06867     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06868     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
06869   }
06870   if (SWIG_IsTmpObj(res3)) {
06871     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
06872   } else {
06873     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06874     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
06875   }
06876   if (SWIG_IsTmpObj(res4)) {
06877     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
06878   } else {
06879     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06880     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
06881   }
06882   return resultobj;
06883 fail:
06884   return NULL;
06885 }
06886 
06887 
06888 SWIGINTERN PyObject *_wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06889   PyObject *resultobj = 0;
06890   PLINT *arg1 = (PLINT *) 0 ;
06891   PLINT *arg2 = (PLINT *) 0 ;
06892   PLINT *arg3 = (PLINT *) 0 ;
06893   PLINT temp1 ;
06894   int res1 = SWIG_TMPOBJ ;
06895   PLINT temp2 ;
06896   int res2 = SWIG_TMPOBJ ;
06897   PLINT temp3 ;
06898   int res3 = SWIG_TMPOBJ ;
06899   
06900   arg1 = &temp1;
06901   arg2 = &temp2;
06902   arg3 = &temp3;
06903   if (!PyArg_ParseTuple(args,(char *)":plgfam")) SWIG_fail;
06904   plgfam(arg1,arg2,arg3);
06905   resultobj = SWIG_Py_Void();
06906   if (SWIG_IsTmpObj(res1)) {
06907     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
06908   } else {
06909     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06910     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
06911   }
06912   if (SWIG_IsTmpObj(res2)) {
06913     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
06914   } else {
06915     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06916     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
06917   }
06918   if (SWIG_IsTmpObj(res3)) {
06919     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
06920   } else {
06921     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06922     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
06923   }
06924   return resultobj;
06925 fail:
06926   return NULL;
06927 }
06928 
06929 
06930 SWIGINTERN PyObject *_wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06931   PyObject *resultobj = 0;
06932   PLUNICODE *arg1 = (PLUNICODE *) 0 ;
06933   PLUNICODE temp1 ;
06934   int res1 = SWIG_TMPOBJ ;
06935   
06936   arg1 = &temp1;
06937   if (!PyArg_ParseTuple(args,(char *)":plgfci")) SWIG_fail;
06938   plgfci(arg1);
06939   resultobj = SWIG_Py_Void();
06940   if (SWIG_IsTmpObj(res1)) {
06941     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg1)));
06942   } else {
06943     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06944     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
06945   }
06946   return resultobj;
06947 fail:
06948   return NULL;
06949 }
06950 
06951 
06952 SWIGINTERN PyObject *_wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06953   PyObject *resultobj = 0;
06954   char *arg1 = (char *) 0 ;
06955   char buff1[1000] ;
06956   
06957   {
06958     arg1 = buff1;
06959   }
06960   if (!PyArg_ParseTuple(args,(char *)":plgfnam")) SWIG_fail;
06961   plgfnam(arg1);
06962   resultobj = SWIG_Py_Void();
06963   {
06964     PyObject *o = PyString_FromString( arg1 );
06965     resultobj = t_output_helper( resultobj, o );
06966   }
06967   return resultobj;
06968 fail:
06969   return NULL;
06970 }
06971 
06972 
06973 SWIGINTERN PyObject *_wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06974   PyObject *resultobj = 0;
06975   PLINT *arg1 = (PLINT *) 0 ;
06976   PLINT *arg2 = (PLINT *) 0 ;
06977   PLINT *arg3 = (PLINT *) 0 ;
06978   PLINT temp1 ;
06979   int res1 = SWIG_TMPOBJ ;
06980   PLINT temp2 ;
06981   int res2 = SWIG_TMPOBJ ;
06982   PLINT temp3 ;
06983   int res3 = SWIG_TMPOBJ ;
06984   
06985   arg1 = &temp1;
06986   arg2 = &temp2;
06987   arg3 = &temp3;
06988   if (!PyArg_ParseTuple(args,(char *)":plgfont")) SWIG_fail;
06989   plgfont(arg1,arg2,arg3);
06990   resultobj = SWIG_Py_Void();
06991   if (SWIG_IsTmpObj(res1)) {
06992     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
06993   } else {
06994     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
06995     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
06996   }
06997   if (SWIG_IsTmpObj(res2)) {
06998     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
06999   } else {
07000     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07001     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
07002   }
07003   if (SWIG_IsTmpObj(res3)) {
07004     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
07005   } else {
07006     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07007     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
07008   }
07009   return resultobj;
07010 fail:
07011   return NULL;
07012 }
07013 
07014 
07015 SWIGINTERN PyObject *_wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07016   PyObject *resultobj = 0;
07017   PLINT *arg1 = (PLINT *) 0 ;
07018   PLINT temp1 ;
07019   int res1 = SWIG_TMPOBJ ;
07020   
07021   arg1 = &temp1;
07022   if (!PyArg_ParseTuple(args,(char *)":plglevel")) SWIG_fail;
07023   plglevel(arg1);
07024   resultobj = SWIG_Py_Void();
07025   if (SWIG_IsTmpObj(res1)) {
07026     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
07027   } else {
07028     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07029     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
07030   }
07031   return resultobj;
07032 fail:
07033   return NULL;
07034 }
07035 
07036 
07037 SWIGINTERN PyObject *_wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07038   PyObject *resultobj = 0;
07039   PLFLT *arg1 = (PLFLT *) 0 ;
07040   PLFLT *arg2 = (PLFLT *) 0 ;
07041   PLINT *arg3 = (PLINT *) 0 ;
07042   PLINT *arg4 = (PLINT *) 0 ;
07043   PLINT *arg5 = (PLINT *) 0 ;
07044   PLINT *arg6 = (PLINT *) 0 ;
07045   PLFLT temp1 ;
07046   int res1 = SWIG_TMPOBJ ;
07047   PLFLT temp2 ;
07048   int res2 = SWIG_TMPOBJ ;
07049   PLINT temp3 ;
07050   int res3 = SWIG_TMPOBJ ;
07051   PLINT temp4 ;
07052   int res4 = SWIG_TMPOBJ ;
07053   PLINT temp5 ;
07054   int res5 = SWIG_TMPOBJ ;
07055   PLINT temp6 ;
07056   int res6 = SWIG_TMPOBJ ;
07057   
07058   arg1 = &temp1;
07059   arg2 = &temp2;
07060   arg3 = &temp3;
07061   arg4 = &temp4;
07062   arg5 = &temp5;
07063   arg6 = &temp6;
07064   if (!PyArg_ParseTuple(args,(char *)":plgpage")) SWIG_fail;
07065   plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
07066   resultobj = SWIG_Py_Void();
07067   if (SWIG_IsTmpObj(res1)) {
07068     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
07069   } else {
07070     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07071     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
07072   }
07073   if (SWIG_IsTmpObj(res2)) {
07074     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
07075   } else {
07076     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07077     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
07078   }
07079   if (SWIG_IsTmpObj(res3)) {
07080     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
07081   } else {
07082     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07083     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
07084   }
07085   if (SWIG_IsTmpObj(res4)) {
07086     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
07087   } else {
07088     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07089     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
07090   }
07091   if (SWIG_IsTmpObj(res5)) {
07092     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
07093   } else {
07094     int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07095     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
07096   }
07097   if (SWIG_IsTmpObj(res6)) {
07098     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
07099   } else {
07100     int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07101     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
07102   }
07103   return resultobj;
07104 fail:
07105   return NULL;
07106 }
07107 
07108 
07109 SWIGINTERN PyObject *_wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07110   PyObject *resultobj = 0;
07111   
07112   if (!PyArg_ParseTuple(args,(char *)":plgra")) SWIG_fail;
07113   plgra();
07114   resultobj = SWIG_Py_Void();
07115   return resultobj;
07116 fail:
07117   return NULL;
07118 }
07119 
07120 
07121 SWIGINTERN PyObject *_wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07122   PyObject *resultobj = 0;
07123   PLFLT *arg1 = (PLFLT *) 0 ;
07124   PLFLT *arg2 = (PLFLT *) 0 ;
07125   PLFLT *arg3 = (PLFLT *) 0 ;
07126   PLINT arg4 ;
07127   PLFLT *arg5 = (PLFLT *) 0 ;
07128   PLINT arg6 ;
07129   PLFLT *arg7 = (PLFLT *) 0 ;
07130   PLINT arg8 ;
07131   PLFLT **arg9 = (PLFLT **) 0 ;
07132   PLINT arg10 ;
07133   PLFLT arg11 ;
07134   PyArrayObject *tmp1 = NULL ;
07135   PyArrayObject *tmp2 = NULL ;
07136   PyArrayObject *tmp3 = NULL ;
07137   PyArrayObject *tmp5 = NULL ;
07138   PyArrayObject *tmp7 = NULL ;
07139   PyObject *array7 = NULL ;
07140   int val10 ;
07141   int ecode10 = 0 ;
07142   double val11 ;
07143   int ecode11 = 0 ;
07144   PyObject * obj0 = 0 ;
07145   PyObject * obj1 = 0 ;
07146   PyObject * obj2 = 0 ;
07147   PyObject * obj3 = 0 ;
07148   PyObject * obj4 = 0 ;
07149   PyObject * obj5 = 0 ;
07150   PyObject * obj6 = 0 ;
07151   
07152   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plgriddata",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
07153   {
07154     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
07155     if ( tmp1 == NULL )
07156     return NULL;
07157     Alen = PyArray_DIMS( tmp1 )[0];
07158     arg1   = (PLFLT *) PyArray_DATA( tmp1 );
07159   }
07160   {
07161     tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
07162     if ( tmp2 == NULL )
07163     return NULL;
07164     if ( PyArray_DIMS( tmp2 )[0] != Alen )
07165     {
07166       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07167       return NULL;
07168     }
07169     arg2 = (PLFLT *) PyArray_DATA( tmp2 );
07170   }
07171   {
07172     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
07173     if ( tmp3 == NULL )
07174     return NULL;
07175     if ( PyArray_DIMS( tmp3 )[0] != Alen )
07176     {
07177       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07178       return NULL;
07179     }
07180     arg3 = (PLFLT *) PyArray_DATA( tmp3 );
07181     arg4 = PyArray_DIMS( tmp3 )[0];
07182   }
07183   {
07184     tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
07185     if ( tmp5 == NULL )
07186     return NULL;
07187     Xlen = PyArray_DIMS( tmp5 )[0];
07188     arg6   = Xlen;
07189     arg5   = (PLFLT *) PyArray_DATA( tmp5 );
07190   }
07191   {
07192     int      i, size;
07193     npy_intp dims[2];
07194     tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
07195     if ( tmp7 == NULL )
07196     return NULL;
07197     Ylen = PyArray_DIMS( tmp7 )[0];
07198     arg8   = Ylen;
07199     arg7   = (PLFLT *) PyArray_DATA( tmp7 );
07200     // Make created 2D array7 have dimensions from prior ArrayX in the argument
07201     // list and this ArrayY.
07202     dims[0] = Xlen;
07203     dims[1] = Ylen;
07204     array7   = PyArray_SimpleNew( 2, dims, NPY_FLOAT64 );
07205     if ( !array7 )
07206     return NULL;
07207     size = Ylen;
07208     arg9   = (double **) malloc( sizeof ( double * ) * (size_t) Xlen );
07209     for ( i = 0; i < Xlen; i++ )
07210     arg9[i] = ( (double *) PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
07211   }
07212   ecode10 = SWIG_AsVal_int(obj5, &val10);
07213   if (!SWIG_IsOK(ecode10)) {
07214     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
07215   } 
07216   arg10 = (PLINT)(val10);
07217   ecode11 = SWIG_AsVal_double(obj6, &val11);
07218   if (!SWIG_IsOK(ecode11)) {
07219     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
07220   } 
07221   arg11 = (PLFLT)(val11);
07222   plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
07223   resultobj = SWIG_Py_Void();
07224   {
07225     resultobj = SWIG_Python_AppendOutput( resultobj, array7 );
07226   }
07227   {
07228     Py_CLEAR( tmp1 );
07229   }
07230   {
07231     Py_CLEAR( tmp2 );
07232   }
07233   {
07234     Py_CLEAR( tmp3 );
07235   }
07236   {
07237     Py_CLEAR( tmp5 );
07238   }
07239   {
07240     Py_CLEAR( tmp7 );
07241     free( arg9 );
07242   }
07243   return resultobj;
07244 fail:
07245   {
07246     Py_CLEAR( tmp1 );
07247   }
07248   {
07249     Py_CLEAR( tmp2 );
07250   }
07251   {
07252     Py_CLEAR( tmp3 );
07253   }
07254   {
07255     Py_CLEAR( tmp5 );
07256   }
07257   {
07258     Py_CLEAR( tmp7 );
07259     free( arg9 );
07260   }
07261   return NULL;
07262 }
07263 
07264 
07265 SWIGINTERN PyObject *_wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07266   PyObject *resultobj = 0;
07267   PLFLT *arg1 = (PLFLT *) 0 ;
07268   PLFLT *arg2 = (PLFLT *) 0 ;
07269   PLFLT *arg3 = (PLFLT *) 0 ;
07270   PLFLT *arg4 = (PLFLT *) 0 ;
07271   PLFLT temp1 ;
07272   int res1 = SWIG_TMPOBJ ;
07273   PLFLT temp2 ;
07274   int res2 = SWIG_TMPOBJ ;
07275   PLFLT temp3 ;
07276   int res3 = SWIG_TMPOBJ ;
07277   PLFLT temp4 ;
07278   int res4 = SWIG_TMPOBJ ;
07279   
07280   arg1 = &temp1;
07281   arg2 = &temp2;
07282   arg3 = &temp3;
07283   arg4 = &temp4;
07284   if (!PyArg_ParseTuple(args,(char *)":plgspa")) SWIG_fail;
07285   plgspa(arg1,arg2,arg3,arg4);
07286   resultobj = SWIG_Py_Void();
07287   if (SWIG_IsTmpObj(res1)) {
07288     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
07289   } else {
07290     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07291     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
07292   }
07293   if (SWIG_IsTmpObj(res2)) {
07294     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
07295   } else {
07296     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07297     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
07298   }
07299   if (SWIG_IsTmpObj(res3)) {
07300     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
07301   } else {
07302     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07303     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
07304   }
07305   if (SWIG_IsTmpObj(res4)) {
07306     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
07307   } else {
07308     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07309     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
07310   }
07311   return resultobj;
07312 fail:
07313   return NULL;
07314 }
07315 
07316 
07317 SWIGINTERN PyObject *_wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07318   PyObject *resultobj = 0;
07319   PLINT *arg1 = (PLINT *) 0 ;
07320   PLINT temp1 ;
07321   int res1 = SWIG_TMPOBJ ;
07322   
07323   arg1 = &temp1;
07324   if (!PyArg_ParseTuple(args,(char *)":plgstrm")) SWIG_fail;
07325   plgstrm(arg1);
07326   resultobj = SWIG_Py_Void();
07327   if (SWIG_IsTmpObj(res1)) {
07328     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
07329   } else {
07330     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07331     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
07332   }
07333   return resultobj;
07334 fail:
07335   return NULL;
07336 }
07337 
07338 
07339 SWIGINTERN PyObject *_wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07340   PyObject *resultobj = 0;
07341   char *arg1 = (char *) 0 ;
07342   char buff1[1000] ;
07343   
07344   {
07345     arg1 = buff1;
07346   }
07347   if (!PyArg_ParseTuple(args,(char *)":plgver")) SWIG_fail;
07348   plgver(arg1);
07349   resultobj = SWIG_Py_Void();
07350   {
07351     PyObject *o = PyString_FromString( arg1 );
07352     resultobj = t_output_helper( resultobj, o );
07353   }
07354   return resultobj;
07355 fail:
07356   return NULL;
07357 }
07358 
07359 
07360 SWIGINTERN PyObject *_wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07361   PyObject *resultobj = 0;
07362   PLFLT *arg1 = (PLFLT *) 0 ;
07363   PLFLT *arg2 = (PLFLT *) 0 ;
07364   PLFLT *arg3 = (PLFLT *) 0 ;
07365   PLFLT *arg4 = (PLFLT *) 0 ;
07366   PLFLT temp1 ;
07367   int res1 = SWIG_TMPOBJ ;
07368   PLFLT temp2 ;
07369   int res2 = SWIG_TMPOBJ ;
07370   PLFLT temp3 ;
07371   int res3 = SWIG_TMPOBJ ;
07372   PLFLT temp4 ;
07373   int res4 = SWIG_TMPOBJ ;
07374   
07375   arg1 = &temp1;
07376   arg2 = &temp2;
07377   arg3 = &temp3;
07378   arg4 = &temp4;
07379   if (!PyArg_ParseTuple(args,(char *)":plgvpd")) SWIG_fail;
07380   plgvpd(arg1,arg2,arg3,arg4);
07381   resultobj = SWIG_Py_Void();
07382   if (SWIG_IsTmpObj(res1)) {
07383     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
07384   } else {
07385     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07386     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
07387   }
07388   if (SWIG_IsTmpObj(res2)) {
07389     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
07390   } else {
07391     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07392     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
07393   }
07394   if (SWIG_IsTmpObj(res3)) {
07395     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
07396   } else {
07397     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07398     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
07399   }
07400   if (SWIG_IsTmpObj(res4)) {
07401     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
07402   } else {
07403     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07404     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
07405   }
07406   return resultobj;
07407 fail:
07408   return NULL;
07409 }
07410 
07411 
07412 SWIGINTERN PyObject *_wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07413   PyObject *resultobj = 0;
07414   PLFLT *arg1 = (PLFLT *) 0 ;
07415   PLFLT *arg2 = (PLFLT *) 0 ;
07416   PLFLT *arg3 = (PLFLT *) 0 ;
07417   PLFLT *arg4 = (PLFLT *) 0 ;
07418   PLFLT temp1 ;
07419   int res1 = SWIG_TMPOBJ ;
07420   PLFLT temp2 ;
07421   int res2 = SWIG_TMPOBJ ;
07422   PLFLT temp3 ;
07423   int res3 = SWIG_TMPOBJ ;
07424   PLFLT temp4 ;
07425   int res4 = SWIG_TMPOBJ ;
07426   
07427   arg1 = &temp1;
07428   arg2 = &temp2;
07429   arg3 = &temp3;
07430   arg4 = &temp4;
07431   if (!PyArg_ParseTuple(args,(char *)":plgvpw")) SWIG_fail;
07432   plgvpw(arg1,arg2,arg3,arg4);
07433   resultobj = SWIG_Py_Void();
07434   if (SWIG_IsTmpObj(res1)) {
07435     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
07436   } else {
07437     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07438     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
07439   }
07440   if (SWIG_IsTmpObj(res2)) {
07441     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
07442   } else {
07443     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07444     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
07445   }
07446   if (SWIG_IsTmpObj(res3)) {
07447     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
07448   } else {
07449     int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07450     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
07451   }
07452   if (SWIG_IsTmpObj(res4)) {
07453     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
07454   } else {
07455     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07456     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
07457   }
07458   return resultobj;
07459 fail:
07460   return NULL;
07461 }
07462 
07463 
07464 SWIGINTERN PyObject *_wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07465   PyObject *resultobj = 0;
07466   PLINT *arg1 = (PLINT *) 0 ;
07467   PLINT *arg2 = (PLINT *) 0 ;
07468   PLINT temp1 ;
07469   int res1 = SWIG_TMPOBJ ;
07470   PLINT temp2 ;
07471   int res2 = SWIG_TMPOBJ ;
07472   
07473   arg1 = &temp1;
07474   arg2 = &temp2;
07475   if (!PyArg_ParseTuple(args,(char *)":plgxax")) SWIG_fail;
07476   plgxax(arg1,arg2);
07477   resultobj = SWIG_Py_Void();
07478   if (SWIG_IsTmpObj(res1)) {
07479     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
07480   } else {
07481     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07482     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
07483   }
07484   if (SWIG_IsTmpObj(res2)) {
07485     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
07486   } else {
07487     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07488     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
07489   }
07490   return resultobj;
07491 fail:
07492   return NULL;
07493 }
07494 
07495 
07496 SWIGINTERN PyObject *_wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07497   PyObject *resultobj = 0;
07498   PLINT *arg1 = (PLINT *) 0 ;
07499   PLINT *arg2 = (PLINT *) 0 ;
07500   PLINT temp1 ;
07501   int res1 = SWIG_TMPOBJ ;
07502   PLINT temp2 ;
07503   int res2 = SWIG_TMPOBJ ;
07504   
07505   arg1 = &temp1;
07506   arg2 = &temp2;
07507   if (!PyArg_ParseTuple(args,(char *)":plgyax")) SWIG_fail;
07508   plgyax(arg1,arg2);
07509   resultobj = SWIG_Py_Void();
07510   if (SWIG_IsTmpObj(res1)) {
07511     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
07512   } else {
07513     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07514     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
07515   }
07516   if (SWIG_IsTmpObj(res2)) {
07517     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
07518   } else {
07519     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07520     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
07521   }
07522   return resultobj;
07523 fail:
07524   return NULL;
07525 }
07526 
07527 
07528 SWIGINTERN PyObject *_wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07529   PyObject *resultobj = 0;
07530   PLINT *arg1 = (PLINT *) 0 ;
07531   PLINT *arg2 = (PLINT *) 0 ;
07532   PLINT temp1 ;
07533   int res1 = SWIG_TMPOBJ ;
07534   PLINT temp2 ;
07535   int res2 = SWIG_TMPOBJ ;
07536   
07537   arg1 = &temp1;
07538   arg2 = &temp2;
07539   if (!PyArg_ParseTuple(args,(char *)":plgzax")) SWIG_fail;
07540   plgzax(arg1,arg2);
07541   resultobj = SWIG_Py_Void();
07542   if (SWIG_IsTmpObj(res1)) {
07543     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
07544   } else {
07545     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07546     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
07547   }
07548   if (SWIG_IsTmpObj(res2)) {
07549     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
07550   } else {
07551     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07552     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
07553   }
07554   return resultobj;
07555 fail:
07556   return NULL;
07557 }
07558 
07559 
07560 SWIGINTERN PyObject *_wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07561   PyObject *resultobj = 0;
07562   PLINT arg1 ;
07563   PLFLT *arg2 = (PLFLT *) 0 ;
07564   PLFLT arg3 ;
07565   PLFLT arg4 ;
07566   PLINT arg5 ;
07567   PLINT arg6 ;
07568   PyArrayObject *tmp1 = NULL ;
07569   double val3 ;
07570   int ecode3 = 0 ;
07571   double val4 ;
07572   int ecode4 = 0 ;
07573   int val5 ;
07574   int ecode5 = 0 ;
07575   int val6 ;
07576   int ecode6 = 0 ;
07577   PyObject * obj0 = 0 ;
07578   PyObject * obj1 = 0 ;
07579   PyObject * obj2 = 0 ;
07580   PyObject * obj3 = 0 ;
07581   PyObject * obj4 = 0 ;
07582   
07583   if (!PyArg_ParseTuple(args,(char *)"OOOOO:plhist",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
07584   {
07585     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
07586     if ( tmp1 == NULL )
07587     return NULL;
07588     arg1 = Alen = PyArray_DIMS( tmp1 )[0];
07589     arg2 = (PLFLT *) PyArray_DATA( tmp1 );
07590   }
07591   ecode3 = SWIG_AsVal_double(obj1, &val3);
07592   if (!SWIG_IsOK(ecode3)) {
07593     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
07594   } 
07595   arg3 = (PLFLT)(val3);
07596   ecode4 = SWIG_AsVal_double(obj2, &val4);
07597   if (!SWIG_IsOK(ecode4)) {
07598     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
07599   } 
07600   arg4 = (PLFLT)(val4);
07601   ecode5 = SWIG_AsVal_int(obj3, &val5);
07602   if (!SWIG_IsOK(ecode5)) {
07603     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
07604   } 
07605   arg5 = (PLINT)(val5);
07606   ecode6 = SWIG_AsVal_int(obj4, &val6);
07607   if (!SWIG_IsOK(ecode6)) {
07608     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
07609   } 
07610   arg6 = (PLINT)(val6);
07611   plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
07612   resultobj = SWIG_Py_Void();
07613   {
07614     Py_CLEAR( tmp1 );
07615   }
07616   return resultobj;
07617 fail:
07618   {
07619     Py_CLEAR( tmp1 );
07620   }
07621   return NULL;
07622 }
07623 
07624 
07625 SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07626   PyObject *resultobj = 0;
07627   PLFLT arg1 ;
07628   PLFLT arg2 ;
07629   PLFLT arg3 ;
07630   PLFLT *arg4 = (PLFLT *) 0 ;
07631   PLFLT *arg5 = (PLFLT *) 0 ;
07632   PLFLT *arg6 = (PLFLT *) 0 ;
07633   double val1 ;
07634   int ecode1 = 0 ;
07635   double val2 ;
07636   int ecode2 = 0 ;
07637   double val3 ;
07638   int ecode3 = 0 ;
07639   PLFLT temp4 ;
07640   int res4 = SWIG_TMPOBJ ;
07641   PLFLT temp5 ;
07642   int res5 = SWIG_TMPOBJ ;
07643   PLFLT temp6 ;
07644   int res6 = SWIG_TMPOBJ ;
07645   PyObject * obj0 = 0 ;
07646   PyObject * obj1 = 0 ;
07647   PyObject * obj2 = 0 ;
07648   
07649   arg4 = &temp4;
07650   arg5 = &temp5;
07651   arg6 = &temp6;
07652   if (!PyArg_ParseTuple(args,(char *)"OOO:plhlsrgb",&obj0,&obj1,&obj2)) SWIG_fail;
07653   ecode1 = SWIG_AsVal_double(obj0, &val1);
07654   if (!SWIG_IsOK(ecode1)) {
07655     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
07656   } 
07657   arg1 = (PLFLT)(val1);
07658   ecode2 = SWIG_AsVal_double(obj1, &val2);
07659   if (!SWIG_IsOK(ecode2)) {
07660     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
07661   } 
07662   arg2 = (PLFLT)(val2);
07663   ecode3 = SWIG_AsVal_double(obj2, &val3);
07664   if (!SWIG_IsOK(ecode3)) {
07665     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
07666   } 
07667   arg3 = (PLFLT)(val3);
07668   plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
07669   resultobj = SWIG_Py_Void();
07670   if (SWIG_IsTmpObj(res4)) {
07671     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
07672   } else {
07673     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07674     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
07675   }
07676   if (SWIG_IsTmpObj(res5)) {
07677     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
07678   } else {
07679     int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07680     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
07681   }
07682   if (SWIG_IsTmpObj(res6)) {
07683     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
07684   } else {
07685     int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
07686     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
07687   }
07688   return resultobj;
07689 fail:
07690   return NULL;
07691 }
07692 
07693 
07694 SWIGINTERN PyObject *_wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07695   PyObject *resultobj = 0;
07696   
07697   if (!PyArg_ParseTuple(args,(char *)":plinit")) SWIG_fail;
07698   plinit();
07699   resultobj = SWIG_Py_Void();
07700   return resultobj;
07701 fail:
07702   return NULL;
07703 }
07704 
07705 
07706 SWIGINTERN PyObject *_wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07707   PyObject *resultobj = 0;
07708   PLFLT arg1 ;
07709   PLFLT arg2 ;
07710   PLFLT arg3 ;
07711   PLFLT arg4 ;
07712   double val1 ;
07713   int ecode1 = 0 ;
07714   double val2 ;
07715   int ecode2 = 0 ;
07716   double val3 ;
07717   int ecode3 = 0 ;
07718   double val4 ;
07719   int ecode4 = 0 ;
07720   PyObject * obj0 = 0 ;
07721   PyObject * obj1 = 0 ;
07722   PyObject * obj2 = 0 ;
07723   PyObject * obj3 = 0 ;
07724   
07725   if (!PyArg_ParseTuple(args,(char *)"OOOO:pljoin",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
07726   ecode1 = SWIG_AsVal_double(obj0, &val1);
07727   if (!SWIG_IsOK(ecode1)) {
07728     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
07729   } 
07730   arg1 = (PLFLT)(val1);
07731   ecode2 = SWIG_AsVal_double(obj1, &val2);
07732   if (!SWIG_IsOK(ecode2)) {
07733     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
07734   } 
07735   arg2 = (PLFLT)(val2);
07736   ecode3 = SWIG_AsVal_double(obj2, &val3);
07737   if (!SWIG_IsOK(ecode3)) {
07738     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
07739   } 
07740   arg3 = (PLFLT)(val3);
07741   ecode4 = SWIG_AsVal_double(obj3, &val4);
07742   if (!SWIG_IsOK(ecode4)) {
07743     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
07744   } 
07745   arg4 = (PLFLT)(val4);
07746   pljoin(arg1,arg2,arg3,arg4);
07747   resultobj = SWIG_Py_Void();
07748   return resultobj;
07749 fail:
07750   return NULL;
07751 }
07752 
07753 
07754 SWIGINTERN PyObject *_wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07755   PyObject *resultobj = 0;
07756   char *arg1 = (char *) 0 ;
07757   char *arg2 = (char *) 0 ;
07758   char *arg3 = (char *) 0 ;
07759   int res1 ;
07760   char *buf1 = 0 ;
07761   int alloc1 = 0 ;
07762   int res2 ;
07763   char *buf2 = 0 ;
07764   int alloc2 = 0 ;
07765   int res3 ;
07766   char *buf3 = 0 ;
07767   int alloc3 = 0 ;
07768   PyObject * obj0 = 0 ;
07769   PyObject * obj1 = 0 ;
07770   PyObject * obj2 = 0 ;
07771   
07772   if (!PyArg_ParseTuple(args,(char *)"OOO:pllab",&obj0,&obj1,&obj2)) SWIG_fail;
07773   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
07774   if (!SWIG_IsOK(res1)) {
07775     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
07776   }
07777   arg1 = (char *)(buf1);
07778   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
07779   if (!SWIG_IsOK(res2)) {
07780     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
07781   }
07782   arg2 = (char *)(buf2);
07783   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
07784   if (!SWIG_IsOK(res3)) {
07785     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
07786   }
07787   arg3 = (char *)(buf3);
07788   pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
07789   resultobj = SWIG_Py_Void();
07790   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
07791   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
07792   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
07793   return resultobj;
07794 fail:
07795   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
07796   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
07797   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
07798   return NULL;
07799 }
07800 
07801 
07802 SWIGINTERN PyObject *_wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07803   PyObject *resultobj = 0;
07804   PLFLT *arg1 = (PLFLT *) 0 ;
07805   PLFLT *arg2 = (PLFLT *) 0 ;
07806   PLINT arg3 ;
07807   PLINT arg4 ;
07808   PLFLT arg5 ;
07809   PLFLT arg6 ;
07810   PLFLT arg7 ;
07811   PLINT arg8 ;
07812   PLINT arg9 ;
07813   PLINT arg10 ;
07814   PLINT arg11 ;
07815   PLINT arg12 ;
07816   PLINT arg13 ;
07817   PLINT *arg14 = (PLINT *) 0 ;
07818   PLFLT arg15 ;
07819   PLFLT arg16 ;
07820   PLFLT arg17 ;
07821   PLFLT arg18 ;
07822   PLINT *arg19 = (PLINT *) 0 ;
07823   char **arg20 = (char **) 0 ;
07824   PLINT *arg21 = (PLINT *) 0 ;
07825   PLINT *arg22 = (PLINT *) 0 ;
07826   PLFLT *arg23 = (PLFLT *) 0 ;
07827   PLFLT *arg24 = (PLFLT *) 0 ;
07828   PLINT *arg25 = (PLINT *) 0 ;
07829   PLINT *arg26 = (PLINT *) 0 ;
07830   PLFLT *arg27 = (PLFLT *) 0 ;
07831   PLINT *arg28 = (PLINT *) 0 ;
07832   PLFLT *arg29 = (PLFLT *) 0 ;
07833   PLINT *arg30 = (PLINT *) 0 ;
07834   char **arg31 = (char **) 0 ;
07835   PLFLT temp1 ;
07836   int res1 = SWIG_TMPOBJ ;
07837   PLFLT temp2 ;
07838   int res2 = SWIG_TMPOBJ ;
07839   int val3 ;
07840   int ecode3 = 0 ;
07841   int val4 ;
07842   int ecode4 = 0 ;
07843   double val5 ;
07844   int ecode5 = 0 ;
07845   double val6 ;
07846   int ecode6 = 0 ;
07847   double val7 ;
07848   int ecode7 = 0 ;
07849   int val8 ;
07850   int ecode8 = 0 ;
07851   int val9 ;
07852   int ecode9 = 0 ;
07853   int val10 ;
07854   int ecode10 = 0 ;
07855   int val11 ;
07856   int ecode11 = 0 ;
07857   int val12 ;
07858   int ecode12 = 0 ;
07859   PyArrayObject *tmp13 = NULL ;
07860   double val15 ;
07861   int ecode15 = 0 ;
07862   double val16 ;
07863   int ecode16 = 0 ;
07864   double val17 ;
07865   int ecode17 = 0 ;
07866   double val18 ;
07867   int ecode18 = 0 ;
07868   PyArrayObject *tmp19 = NULL ;
07869   PyArrayObject *tmp20 = NULL ;
07870   PyArrayObject *tmp21 = NULL ;
07871   PyArrayObject *tmp22 = NULL ;
07872   PyArrayObject *tmp23 = NULL ;
07873   PyArrayObject *tmp24 = NULL ;
07874   PyArrayObject *tmp25 = NULL ;
07875   PyArrayObject *tmp26 = NULL ;
07876   PyArrayObject *tmp27 = NULL ;
07877   PyArrayObject *tmp28 = NULL ;
07878   PyArrayObject *tmp29 = NULL ;
07879   PyArrayObject *tmp30 = NULL ;
07880   PyArrayObject *tmp31 = NULL ;
07881   PyObject * obj0 = 0 ;
07882   PyObject * obj1 = 0 ;
07883   PyObject * obj2 = 0 ;
07884   PyObject * obj3 = 0 ;
07885   PyObject * obj4 = 0 ;
07886   PyObject * obj5 = 0 ;
07887   PyObject * obj6 = 0 ;
07888   PyObject * obj7 = 0 ;
07889   PyObject * obj8 = 0 ;
07890   PyObject * obj9 = 0 ;
07891   PyObject * obj10 = 0 ;
07892   PyObject * obj11 = 0 ;
07893   PyObject * obj12 = 0 ;
07894   PyObject * obj13 = 0 ;
07895   PyObject * obj14 = 0 ;
07896   PyObject * obj15 = 0 ;
07897   PyObject * obj16 = 0 ;
07898   PyObject * obj17 = 0 ;
07899   PyObject * obj18 = 0 ;
07900   PyObject * obj19 = 0 ;
07901   PyObject * obj20 = 0 ;
07902   PyObject * obj21 = 0 ;
07903   PyObject * obj22 = 0 ;
07904   PyObject * obj23 = 0 ;
07905   PyObject * obj24 = 0 ;
07906   PyObject * obj25 = 0 ;
07907   PyObject * obj26 = 0 ;
07908   PyObject * obj27 = 0 ;
07909   
07910   arg1 = &temp1;
07911   arg2 = &temp2;
07912   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOOOOOO:pllegend",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23,&obj24,&obj25,&obj26,&obj27)) SWIG_fail;
07913   ecode3 = SWIG_AsVal_int(obj0, &val3);
07914   if (!SWIG_IsOK(ecode3)) {
07915     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
07916   } 
07917   arg3 = (PLINT)(val3);
07918   ecode4 = SWIG_AsVal_int(obj1, &val4);
07919   if (!SWIG_IsOK(ecode4)) {
07920     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
07921   } 
07922   arg4 = (PLINT)(val4);
07923   ecode5 = SWIG_AsVal_double(obj2, &val5);
07924   if (!SWIG_IsOK(ecode5)) {
07925     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
07926   } 
07927   arg5 = (PLFLT)(val5);
07928   ecode6 = SWIG_AsVal_double(obj3, &val6);
07929   if (!SWIG_IsOK(ecode6)) {
07930     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
07931   } 
07932   arg6 = (PLFLT)(val6);
07933   ecode7 = SWIG_AsVal_double(obj4, &val7);
07934   if (!SWIG_IsOK(ecode7)) {
07935     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
07936   } 
07937   arg7 = (PLFLT)(val7);
07938   ecode8 = SWIG_AsVal_int(obj5, &val8);
07939   if (!SWIG_IsOK(ecode8)) {
07940     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
07941   } 
07942   arg8 = (PLINT)(val8);
07943   ecode9 = SWIG_AsVal_int(obj6, &val9);
07944   if (!SWIG_IsOK(ecode9)) {
07945     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
07946   } 
07947   arg9 = (PLINT)(val9);
07948   ecode10 = SWIG_AsVal_int(obj7, &val10);
07949   if (!SWIG_IsOK(ecode10)) {
07950     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
07951   } 
07952   arg10 = (PLINT)(val10);
07953   ecode11 = SWIG_AsVal_int(obj8, &val11);
07954   if (!SWIG_IsOK(ecode11)) {
07955     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
07956   } 
07957   arg11 = (PLINT)(val11);
07958   ecode12 = SWIG_AsVal_int(obj9, &val12);
07959   if (!SWIG_IsOK(ecode12)) {
07960     SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
07961   } 
07962   arg12 = (PLINT)(val12);
07963   {
07964     tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj10, NPY_PLINT, 1, 1 );
07965     if ( tmp13 == NULL )
07966     return NULL;
07967     arg13 = Alen = PyArray_DIMS( tmp13 )[0];
07968     arg14 = (PLINT *) PyArray_DATA( tmp13 );
07969   }
07970   ecode15 = SWIG_AsVal_double(obj11, &val15);
07971   if (!SWIG_IsOK(ecode15)) {
07972     SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
07973   } 
07974   arg15 = (PLFLT)(val15);
07975   ecode16 = SWIG_AsVal_double(obj12, &val16);
07976   if (!SWIG_IsOK(ecode16)) {
07977     SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
07978   } 
07979   arg16 = (PLFLT)(val16);
07980   ecode17 = SWIG_AsVal_double(obj13, &val17);
07981   if (!SWIG_IsOK(ecode17)) {
07982     SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
07983   } 
07984   arg17 = (PLFLT)(val17);
07985   ecode18 = SWIG_AsVal_double(obj14, &val18);
07986   if (!SWIG_IsOK(ecode18)) {
07987     SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
07988   } 
07989   arg18 = (PLFLT)(val18);
07990   {
07991     tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj15, NPY_PLINT, 1, 1 );
07992     if ( tmp19 == NULL )
07993     return NULL;
07994     if ( PyArray_DIMS( tmp19 )[0] != Alen )
07995     {
07996       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
07997       return NULL;
07998     }
07999     arg19 = (PLINT *) PyArray_DATA( tmp19 );
08000   }
08001   {
08002     int i;
08003     tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( obj16, NPY_STRING, 1, 1 );
08004     if ( tmp20 == NULL )
08005     return NULL;
08006     if ( PyArray_DIMS( tmp20 )[0] != Alen )
08007     {
08008       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08009       return NULL;
08010     }
08011     arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
08012     for ( i = 0; i < Alen; i++ )
08013     {
08014       arg20[i] = (char *) PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
08015       if ( arg20[i] == NULL )
08016       {
08017         free( arg20 );
08018         return NULL;
08019       }
08020     }
08021   }
08022   {
08023     tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj17, NPY_PLINT, 1, 1 );
08024     if ( tmp21 == NULL )
08025     return NULL;
08026     if ( PyArray_DIMS( tmp21 )[0] != Alen )
08027     {
08028       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08029       return NULL;
08030     }
08031     arg21 = (PLINT *) PyArray_DATA( tmp21 );
08032   }
08033   {
08034     tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj18, NPY_PLINT, 1, 1 );
08035     if ( tmp22 == NULL )
08036     return NULL;
08037     if ( PyArray_DIMS( tmp22 )[0] != Alen )
08038     {
08039       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08040       return NULL;
08041     }
08042     arg22 = (PLINT *) PyArray_DATA( tmp22 );
08043   }
08044   {
08045     if ( obj19 != Py_None )
08046     {
08047       tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( obj19, NPY_PLFLT, 1, 1 );
08048       if ( tmp23 == NULL )
08049       return NULL;
08050       if ( PyArray_DIMS( tmp23 )[0] != Alen )
08051       {
08052         PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08053         return NULL;
08054       }
08055       arg23 = (PLFLT *) PyArray_DATA( tmp23 );
08056     }
08057     else
08058     {
08059       arg23 = NULL;
08060     }
08061   }
08062   {
08063     if ( obj20 != Py_None )
08064     {
08065       tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( obj20, NPY_PLFLT, 1, 1 );
08066       if ( tmp24 == NULL )
08067       return NULL;
08068       if ( PyArray_DIMS( tmp24 )[0] != Alen )
08069       {
08070         PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08071         return NULL;
08072       }
08073       arg24 = (PLFLT *) PyArray_DATA( tmp24 );
08074     }
08075     else
08076     {
08077       arg24 = NULL;
08078     }
08079   }
08080   {
08081     tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj21, NPY_PLINT, 1, 1 );
08082     if ( tmp25 == NULL )
08083     return NULL;
08084     if ( PyArray_DIMS( tmp25 )[0] != Alen )
08085     {
08086       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08087       return NULL;
08088     }
08089     arg25 = (PLINT *) PyArray_DATA( tmp25 );
08090   }
08091   {
08092     tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj22, NPY_PLINT, 1, 1 );
08093     if ( tmp26 == NULL )
08094     return NULL;
08095     if ( PyArray_DIMS( tmp26 )[0] != Alen )
08096     {
08097       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08098       return NULL;
08099     }
08100     arg26 = (PLINT *) PyArray_DATA( tmp26 );
08101   }
08102   {
08103     if ( obj23 != Py_None )
08104     {
08105       tmp27 = (PyArrayObject *) myArray_ContiguousFromObject( obj23, NPY_PLFLT, 1, 1 );
08106       if ( tmp27 == NULL )
08107       return NULL;
08108       if ( PyArray_DIMS( tmp27 )[0] != Alen )
08109       {
08110         PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08111         return NULL;
08112       }
08113       arg27 = (PLFLT *) PyArray_DATA( tmp27 );
08114     }
08115     else
08116     {
08117       arg27 = NULL;
08118     }
08119   }
08120   {
08121     tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj24, NPY_PLINT, 1, 1 );
08122     if ( tmp28 == NULL )
08123     return NULL;
08124     if ( PyArray_DIMS( tmp28 )[0] != Alen )
08125     {
08126       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08127       return NULL;
08128     }
08129     arg28 = (PLINT *) PyArray_DATA( tmp28 );
08130   }
08131   {
08132     if ( obj25 != Py_None )
08133     {
08134       tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( obj25, NPY_PLFLT, 1, 1 );
08135       if ( tmp29 == NULL )
08136       return NULL;
08137       if ( PyArray_DIMS( tmp29 )[0] != Alen )
08138       {
08139         PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08140         return NULL;
08141       }
08142       arg29 = (PLFLT *) PyArray_DATA( tmp29 );
08143     }
08144     else
08145     {
08146       arg29 = NULL;
08147     }
08148   }
08149   {
08150     tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj26, NPY_PLINT, 1, 1 );
08151     if ( tmp30 == NULL )
08152     return NULL;
08153     if ( PyArray_DIMS( tmp30 )[0] != Alen )
08154     {
08155       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08156       return NULL;
08157     }
08158     arg30 = (PLINT *) PyArray_DATA( tmp30 );
08159   }
08160   {
08161     int i;
08162     tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( obj27, NPY_STRING, 1, 1 );
08163     if ( tmp31 == NULL )
08164     return NULL;
08165     if ( PyArray_DIMS( tmp31 )[0] != Alen )
08166     {
08167       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08168       return NULL;
08169     }
08170     arg31 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
08171     for ( i = 0; i < Alen; i++ )
08172     {
08173       arg31[i] = (char *) PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
08174       if ( arg31[i] == NULL )
08175       {
08176         free( arg31 );
08177         return NULL;
08178       }
08179     }
08180   }
08181   pllegend(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(int const *)arg14,arg15,arg16,arg17,arg18,(int const *)arg19,(char const **)arg20,(int const *)arg21,(int const *)arg22,(double const *)arg23,(double const *)arg24,(int const *)arg25,(int const *)arg26,(double const *)arg27,(int const *)arg28,(double const *)arg29,(int const *)arg30,(char const **)arg31);
08182   resultobj = SWIG_Py_Void();
08183   if (SWIG_IsTmpObj(res1)) {
08184     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
08185   } else {
08186     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
08187     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
08188   }
08189   if (SWIG_IsTmpObj(res2)) {
08190     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
08191   } else {
08192     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
08193     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
08194   }
08195   {
08196     Py_CLEAR( tmp13 );
08197   }
08198   {
08199     Py_CLEAR( tmp19 );
08200   }
08201   {
08202     Py_CLEAR( tmp20 ); free( arg20 );
08203   }
08204   {
08205     Py_CLEAR( tmp21 );
08206   }
08207   {
08208     Py_CLEAR( tmp22 );
08209   }
08210   {
08211     Py_CLEAR( tmp23 );
08212   }
08213   {
08214     Py_CLEAR( tmp24 );
08215   }
08216   {
08217     Py_CLEAR( tmp25 );
08218   }
08219   {
08220     Py_CLEAR( tmp26 );
08221   }
08222   {
08223     Py_CLEAR( tmp27 );
08224   }
08225   {
08226     Py_CLEAR( tmp28 );
08227   }
08228   {
08229     Py_CLEAR( tmp29 );
08230   }
08231   {
08232     Py_CLEAR( tmp30 );
08233   }
08234   {
08235     Py_CLEAR( tmp31 ); free( arg31 );
08236   }
08237   return resultobj;
08238 fail:
08239   {
08240     Py_CLEAR( tmp13 );
08241   }
08242   {
08243     Py_CLEAR( tmp19 );
08244   }
08245   {
08246     Py_CLEAR( tmp20 ); free( arg20 );
08247   }
08248   {
08249     Py_CLEAR( tmp21 );
08250   }
08251   {
08252     Py_CLEAR( tmp22 );
08253   }
08254   {
08255     Py_CLEAR( tmp23 );
08256   }
08257   {
08258     Py_CLEAR( tmp24 );
08259   }
08260   {
08261     Py_CLEAR( tmp25 );
08262   }
08263   {
08264     Py_CLEAR( tmp26 );
08265   }
08266   {
08267     Py_CLEAR( tmp27 );
08268   }
08269   {
08270     Py_CLEAR( tmp28 );
08271   }
08272   {
08273     Py_CLEAR( tmp29 );
08274   }
08275   {
08276     Py_CLEAR( tmp30 );
08277   }
08278   {
08279     Py_CLEAR( tmp31 ); free( arg31 );
08280   }
08281   return NULL;
08282 }
08283 
08284 
08285 SWIGINTERN PyObject *_wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08286   PyObject *resultobj = 0;
08287   PLFLT *arg1 = (PLFLT *) 0 ;
08288   PLFLT *arg2 = (PLFLT *) 0 ;
08289   PLINT arg3 ;
08290   PLINT arg4 ;
08291   PLFLT arg5 ;
08292   PLFLT arg6 ;
08293   PLFLT arg7 ;
08294   PLFLT arg8 ;
08295   PLINT arg9 ;
08296   PLINT arg10 ;
08297   PLINT arg11 ;
08298   PLFLT arg12 ;
08299   PLFLT arg13 ;
08300   PLINT arg14 ;
08301   PLFLT arg15 ;
08302   PLINT arg16 ;
08303   PLINT *arg17 = (PLINT *) 0 ;
08304   char **arg18 = (char **) 0 ;
08305   PLINT arg19 ;
08306   char **arg20 = (char **) 0 ;
08307   PLFLT *arg21 = (PLFLT *) 0 ;
08308   PLINT *arg22 = (PLINT *) 0 ;
08309   PLINT *arg23 = (PLINT *) 0 ;
08310   PLFLT **arg24 = (PLFLT **) 0 ;
08311   PLFLT temp1 ;
08312   int res1 = SWIG_TMPOBJ ;
08313   PLFLT temp2 ;
08314   int res2 = SWIG_TMPOBJ ;
08315   int val3 ;
08316   int ecode3 = 0 ;
08317   int val4 ;
08318   int ecode4 = 0 ;
08319   double val5 ;
08320   int ecode5 = 0 ;
08321   double val6 ;
08322   int ecode6 = 0 ;
08323   double val7 ;
08324   int ecode7 = 0 ;
08325   double val8 ;
08326   int ecode8 = 0 ;
08327   int val9 ;
08328   int ecode9 = 0 ;
08329   int val10 ;
08330   int ecode10 = 0 ;
08331   int val11 ;
08332   int ecode11 = 0 ;
08333   double val12 ;
08334   int ecode12 = 0 ;
08335   double val13 ;
08336   int ecode13 = 0 ;
08337   int val14 ;
08338   int ecode14 = 0 ;
08339   double val15 ;
08340   int ecode15 = 0 ;
08341   PyArrayObject *tmp16 = NULL ;
08342   PyArrayObject *tmp18 = NULL ;
08343   PyArrayObject *tmp19 = NULL ;
08344   PyArrayObject *tmp21 = NULL ;
08345   PyArrayObject *tmp22 = NULL ;
08346   PyArrayObject *tmp23 = NULL ;
08347   PyArrayObject *tmp24 = NULL ;
08348   PyObject * obj0 = 0 ;
08349   PyObject * obj1 = 0 ;
08350   PyObject * obj2 = 0 ;
08351   PyObject * obj3 = 0 ;
08352   PyObject * obj4 = 0 ;
08353   PyObject * obj5 = 0 ;
08354   PyObject * obj6 = 0 ;
08355   PyObject * obj7 = 0 ;
08356   PyObject * obj8 = 0 ;
08357   PyObject * obj9 = 0 ;
08358   PyObject * obj10 = 0 ;
08359   PyObject * obj11 = 0 ;
08360   PyObject * obj12 = 0 ;
08361   PyObject * obj13 = 0 ;
08362   PyObject * obj14 = 0 ;
08363   PyObject * obj15 = 0 ;
08364   PyObject * obj16 = 0 ;
08365   PyObject * obj17 = 0 ;
08366   PyObject * obj18 = 0 ;
08367   PyObject * obj19 = 0 ;
08368   
08369   arg1 = &temp1;
08370   arg2 = &temp2;
08371   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOO:plcolorbar",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19)) SWIG_fail;
08372   ecode3 = SWIG_AsVal_int(obj0, &val3);
08373   if (!SWIG_IsOK(ecode3)) {
08374     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
08375   } 
08376   arg3 = (PLINT)(val3);
08377   ecode4 = SWIG_AsVal_int(obj1, &val4);
08378   if (!SWIG_IsOK(ecode4)) {
08379     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
08380   } 
08381   arg4 = (PLINT)(val4);
08382   ecode5 = SWIG_AsVal_double(obj2, &val5);
08383   if (!SWIG_IsOK(ecode5)) {
08384     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
08385   } 
08386   arg5 = (PLFLT)(val5);
08387   ecode6 = SWIG_AsVal_double(obj3, &val6);
08388   if (!SWIG_IsOK(ecode6)) {
08389     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
08390   } 
08391   arg6 = (PLFLT)(val6);
08392   ecode7 = SWIG_AsVal_double(obj4, &val7);
08393   if (!SWIG_IsOK(ecode7)) {
08394     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
08395   } 
08396   arg7 = (PLFLT)(val7);
08397   ecode8 = SWIG_AsVal_double(obj5, &val8);
08398   if (!SWIG_IsOK(ecode8)) {
08399     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
08400   } 
08401   arg8 = (PLFLT)(val8);
08402   ecode9 = SWIG_AsVal_int(obj6, &val9);
08403   if (!SWIG_IsOK(ecode9)) {
08404     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
08405   } 
08406   arg9 = (PLINT)(val9);
08407   ecode10 = SWIG_AsVal_int(obj7, &val10);
08408   if (!SWIG_IsOK(ecode10)) {
08409     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
08410   } 
08411   arg10 = (PLINT)(val10);
08412   ecode11 = SWIG_AsVal_int(obj8, &val11);
08413   if (!SWIG_IsOK(ecode11)) {
08414     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
08415   } 
08416   arg11 = (PLINT)(val11);
08417   ecode12 = SWIG_AsVal_double(obj9, &val12);
08418   if (!SWIG_IsOK(ecode12)) {
08419     SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
08420   } 
08421   arg12 = (PLFLT)(val12);
08422   ecode13 = SWIG_AsVal_double(obj10, &val13);
08423   if (!SWIG_IsOK(ecode13)) {
08424     SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
08425   } 
08426   arg13 = (PLFLT)(val13);
08427   ecode14 = SWIG_AsVal_int(obj11, &val14);
08428   if (!SWIG_IsOK(ecode14)) {
08429     SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
08430   } 
08431   arg14 = (PLINT)(val14);
08432   ecode15 = SWIG_AsVal_double(obj12, &val15);
08433   if (!SWIG_IsOK(ecode15)) {
08434     SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
08435   } 
08436   arg15 = (PLFLT)(val15);
08437   {
08438     tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj13, NPY_PLINT, 1, 1 );
08439     if ( tmp16 == NULL )
08440     return NULL;
08441     arg16 = Alen = PyArray_DIMS( tmp16 )[0];
08442     arg17 = (PLINT *) PyArray_DATA( tmp16 );
08443   }
08444   {
08445     int i;
08446     tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( obj14, NPY_STRING, 1, 1 );
08447     if ( tmp18 == NULL )
08448     return NULL;
08449     if ( PyArray_DIMS( tmp18 )[0] != Alen )
08450     {
08451       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08452       return NULL;
08453     }
08454     arg18 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
08455     for ( i = 0; i < Alen; i++ )
08456     {
08457       arg18[i] = (char *) PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
08458       if ( arg18[i] == NULL )
08459       {
08460         free( arg18 );
08461         return NULL;
08462       }
08463     }
08464   }
08465   {
08466     int i;
08467     tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( obj15, NPY_STRING, 1, 1 );
08468     if ( tmp19 == NULL )
08469     return NULL;
08470     Alen = PyArray_DIMS( tmp19 )[0];
08471     arg19   = Alen;
08472     arg20   = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
08473     for ( i = 0; i < Alen; i++ )
08474     {
08475       arg20[i] = (char *) PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
08476       if ( arg20[i] == NULL )
08477       {
08478         free( arg20 );
08479         return NULL;
08480       }
08481     }
08482   }
08483   {
08484     tmp21 = (PyArrayObject *) myArray_ContiguousFromObject( obj16, NPY_PLFLT, 1, 1 );
08485     if ( tmp21 == NULL )
08486     return NULL;
08487     if ( PyArray_DIMS( tmp21 )[0] != Alen )
08488     {
08489       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08490       return NULL;
08491     }
08492     arg21 = (PLFLT *) PyArray_DATA( tmp21 );
08493   }
08494   {
08495     tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj17, NPY_PLINT, 1, 1 );
08496     if ( tmp22 == NULL )
08497     return NULL;
08498     if ( PyArray_DIMS( tmp22 )[0] != Alen )
08499     {
08500       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08501       return NULL;
08502     }
08503     arg22 = (PLINT *) PyArray_DATA( tmp22 );
08504   }
08505   {
08506     int i;
08507     tmp23 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj18, NPY_PLINT, 1, 1 );
08508     if ( tmp23 == NULL )
08509     return NULL;
08510     if ( PyArray_DIMS( tmp23 )[0] != Alen )
08511     {
08512       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08513       return NULL;
08514     }
08515     Xlen = PyArray_DIMS( tmp23 )[0];
08516     arg23   = (PLINT *) PyArray_DATA( tmp23 );
08517     Ylen = -1;
08518     for ( i = 0; i < Xlen; i++ )
08519     if ( arg23[i] > Ylen )
08520     Ylen = arg23[i];
08521   }
08522   {
08523     int i, size;
08524     tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( obj19, NPY_PLFLT, 2, 2 );
08525     if ( tmp24 == NULL )
08526     return NULL;
08527     if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] != Ylen )
08528     {
08529       PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
08530       return NULL;
08531     }
08532     size = Ylen;
08533     arg24   = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
08534     for ( i = 0; i < Xlen; i++ )
08535     arg24[i] = ( (PLFLT *) PyArray_DATA( tmp24 ) + i * size );
08536   }
08537   plcolorbar(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,(int const *)arg17,(char const **)arg18,arg19,(char const **)arg20,(double const *)arg21,(int const *)arg22,(int const *)arg23,(double const **)arg24);
08538   resultobj = SWIG_Py_Void();
08539   if (SWIG_IsTmpObj(res1)) {
08540     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
08541   } else {
08542     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
08543     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
08544   }
08545   if (SWIG_IsTmpObj(res2)) {
08546     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
08547   } else {
08548     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
08549     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
08550   }
08551   {
08552     Py_CLEAR( tmp16 );
08553   }
08554   {
08555     Py_CLEAR( tmp18 ); free( arg18 );
08556   }
08557   {
08558     Py_CLEAR( tmp19 ); free( arg20 );
08559   }
08560   {
08561     Py_CLEAR( tmp21 );
08562   }
08563   {
08564     Py_CLEAR( tmp22 );
08565   }
08566   {
08567     Py_CLEAR( tmp23 );
08568   }
08569   {
08570     Py_CLEAR( tmp24 );
08571     free( arg24 );
08572   }
08573   return resultobj;
08574 fail:
08575   {
08576     Py_CLEAR( tmp16 );
08577   }
08578   {
08579     Py_CLEAR( tmp18 ); free( arg18 );
08580   }
08581   {
08582     Py_CLEAR( tmp19 ); free( arg20 );
08583   }
08584   {
08585     Py_CLEAR( tmp21 );
08586   }
08587   {
08588     Py_CLEAR( tmp22 );
08589   }
08590   {
08591     Py_CLEAR( tmp23 );
08592   }
08593   {
08594     Py_CLEAR( tmp24 );
08595     free( arg24 );
08596   }
08597   return NULL;
08598 }
08599 
08600 
08601 SWIGINTERN PyObject *_wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08602   PyObject *resultobj = 0;
08603   PLFLT arg1 ;
08604   PLFLT arg2 ;
08605   PLFLT arg3 ;
08606   double val1 ;
08607   int ecode1 = 0 ;
08608   double val2 ;
08609   int ecode2 = 0 ;
08610   double val3 ;
08611   int ecode3 = 0 ;
08612   PyObject * obj0 = 0 ;
08613   PyObject * obj1 = 0 ;
08614   PyObject * obj2 = 0 ;
08615   
08616   if (!PyArg_ParseTuple(args,(char *)"OOO:pllightsource",&obj0,&obj1,&obj2)) SWIG_fail;
08617   ecode1 = SWIG_AsVal_double(obj0, &val1);
08618   if (!SWIG_IsOK(ecode1)) {
08619     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
08620   } 
08621   arg1 = (PLFLT)(val1);
08622   ecode2 = SWIG_AsVal_double(obj1, &val2);
08623   if (!SWIG_IsOK(ecode2)) {
08624     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
08625   } 
08626   arg2 = (PLFLT)(val2);
08627   ecode3 = SWIG_AsVal_double(obj2, &val3);
08628   if (!SWIG_IsOK(ecode3)) {
08629     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
08630   } 
08631   arg3 = (PLFLT)(val3);
08632   pllightsource(arg1,arg2,arg3);
08633   resultobj = SWIG_Py_Void();
08634   return resultobj;
08635 fail:
08636   return NULL;
08637 }
08638 
08639 
08640 SWIGINTERN PyObject *_wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08641   PyObject *resultobj = 0;
08642   PLINT arg1 ;
08643   PLFLT *arg2 = (PLFLT *) 0 ;
08644   PLFLT *arg3 = (PLFLT *) 0 ;
08645   PyArrayObject *tmp1 = NULL ;
08646   PyArrayObject *tmp3 = NULL ;
08647   PyObject * obj0 = 0 ;
08648   PyObject * obj1 = 0 ;
08649   
08650   if (!PyArg_ParseTuple(args,(char *)"OO:plline",&obj0,&obj1)) SWIG_fail;
08651   {
08652     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
08653     if ( tmp1 == NULL )
08654     return NULL;
08655     arg1 = Alen = PyArray_DIMS( tmp1 )[0];
08656     arg2 = (PLFLT *) PyArray_DATA( tmp1 );
08657   }
08658   {
08659     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
08660     if ( tmp3 == NULL )
08661     return NULL;
08662     if ( PyArray_DIMS( tmp3 )[0] != Alen )
08663     {
08664       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08665       return NULL;
08666     }
08667     arg3 = (PLFLT *) PyArray_DATA( tmp3 );
08668   }
08669   plline(arg1,(double const *)arg2,(double const *)arg3);
08670   resultobj = SWIG_Py_Void();
08671   {
08672     Py_CLEAR( tmp1 );
08673   }
08674   {
08675     Py_CLEAR( tmp3 );
08676   }
08677   return resultobj;
08678 fail:
08679   {
08680     Py_CLEAR( tmp1 );
08681   }
08682   {
08683     Py_CLEAR( tmp3 );
08684   }
08685   return NULL;
08686 }
08687 
08688 
08689 SWIGINTERN PyObject *_wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08690   PyObject *resultobj = 0;
08691   PLINT arg1 ;
08692   PLFLT *arg2 = (PLFLT *) 0 ;
08693   PLFLT *arg3 = (PLFLT *) 0 ;
08694   PLFLT *arg4 = (PLFLT *) 0 ;
08695   PyArrayObject *tmp1 = NULL ;
08696   PyArrayObject *tmp3 = NULL ;
08697   PyArrayObject *tmp4 = NULL ;
08698   PyObject * obj0 = 0 ;
08699   PyObject * obj1 = 0 ;
08700   PyObject * obj2 = 0 ;
08701   
08702   if (!PyArg_ParseTuple(args,(char *)"OOO:plline3",&obj0,&obj1,&obj2)) SWIG_fail;
08703   {
08704     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
08705     if ( tmp1 == NULL )
08706     return NULL;
08707     arg1 = Alen = PyArray_DIMS( tmp1 )[0];
08708     arg2 = (PLFLT *) PyArray_DATA( tmp1 );
08709   }
08710   {
08711     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
08712     if ( tmp3 == NULL )
08713     return NULL;
08714     if ( PyArray_DIMS( tmp3 )[0] != Alen )
08715     {
08716       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08717       return NULL;
08718     }
08719     arg3 = (PLFLT *) PyArray_DATA( tmp3 );
08720   }
08721   {
08722     tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
08723     if ( tmp4 == NULL )
08724     return NULL;
08725     if ( PyArray_DIMS( tmp4 )[0] != Alen )
08726     {
08727       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
08728       return NULL;
08729     }
08730     arg4 = (PLFLT *) PyArray_DATA( tmp4 );
08731   }
08732   plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
08733   resultobj = SWIG_Py_Void();
08734   {
08735     Py_CLEAR( tmp1 );
08736   }
08737   {
08738     Py_CLEAR( tmp3 );
08739   }
08740   {
08741     Py_CLEAR( tmp4 );
08742   }
08743   return resultobj;
08744 fail:
08745   {
08746     Py_CLEAR( tmp1 );
08747   }
08748   {
08749     Py_CLEAR( tmp3 );
08750   }
08751   {
08752     Py_CLEAR( tmp4 );
08753   }
08754   return NULL;
08755 }
08756 
08757 
08758 SWIGINTERN PyObject *_wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08759   PyObject *resultobj = 0;
08760   PLINT arg1 ;
08761   int val1 ;
08762   int ecode1 = 0 ;
08763   PyObject * obj0 = 0 ;
08764   
08765   if (!PyArg_ParseTuple(args,(char *)"O:pllsty",&obj0)) SWIG_fail;
08766   ecode1 = SWIG_AsVal_int(obj0, &val1);
08767   if (!SWIG_IsOK(ecode1)) {
08768     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
08769   } 
08770   arg1 = (PLINT)(val1);
08771   pllsty(arg1);
08772   resultobj = SWIG_Py_Void();
08773   return resultobj;
08774 fail:
08775   return NULL;
08776 }
08777 
08778 
08779 SWIGINTERN PyObject *_wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08780   PyObject *resultobj = 0;
08781   PLFLT *arg1 = (PLFLT *) 0 ;
08782   PLFLT *arg2 = (PLFLT *) 0 ;
08783   PLFLT **arg3 = (PLFLT **) 0 ;
08784   PLINT arg4 ;
08785   PLINT arg5 ;
08786   PLINT arg6 ;
08787   PyArrayObject *tmp1 = NULL ;
08788   PyArrayObject *tmp2 = NULL ;
08789   PyArrayObject *tmp3 = NULL ;
08790   int val6 ;
08791   int ecode6 = 0 ;
08792   PyObject * obj0 = 0 ;
08793   PyObject * obj1 = 0 ;
08794   PyObject * obj2 = 0 ;
08795   PyObject * obj3 = 0 ;
08796   
08797   if (!PyArg_ParseTuple(args,(char *)"OOOO:plmesh",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
08798   {
08799     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
08800     if ( tmp1 == NULL )
08801     return NULL;
08802     Xlen = PyArray_DIMS( tmp1 )[0];
08803     arg1   = (PLFLT *) PyArray_DATA( tmp1 );
08804   }
08805   {
08806     tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
08807     if ( tmp2 == NULL )
08808     return NULL;
08809     Ylen = PyArray_DIMS( tmp2 )[0];
08810     arg2   = (PLFLT *) PyArray_DATA( tmp2 );
08811   }
08812   {
08813     int i, size;
08814     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
08815     if ( tmp3 == NULL )
08816     return NULL;
08817     if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
08818     {
08819       PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
08820       return NULL;
08821     }
08822     arg4   = PyArray_DIMS( tmp3 )[0];
08823     arg5   = PyArray_DIMS( tmp3 )[1];
08824     size = arg5;
08825     arg3   = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
08826     for ( i = 0; i < arg4; i++ )
08827     arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
08828   }
08829   ecode6 = SWIG_AsVal_int(obj3, &val6);
08830   if (!SWIG_IsOK(ecode6)) {
08831     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
08832   } 
08833   arg6 = (PLINT)(val6);
08834   plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
08835   resultobj = SWIG_Py_Void();
08836   {
08837     Py_CLEAR( tmp1 );
08838   }
08839   {
08840     Py_CLEAR( tmp2 );
08841   }
08842   {
08843     Py_CLEAR( tmp3 );
08844     free( arg3 );
08845   }
08846   return resultobj;
08847 fail:
08848   {
08849     Py_CLEAR( tmp1 );
08850   }
08851   {
08852     Py_CLEAR( tmp2 );
08853   }
08854   {
08855     Py_CLEAR( tmp3 );
08856     free( arg3 );
08857   }
08858   return NULL;
08859 }
08860 
08861 
08862 SWIGINTERN PyObject *_wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08863   PyObject *resultobj = 0;
08864   PLFLT *arg1 = (PLFLT *) 0 ;
08865   PLFLT *arg2 = (PLFLT *) 0 ;
08866   PLFLT **arg3 = (PLFLT **) 0 ;
08867   PLINT arg4 ;
08868   PLINT arg5 ;
08869   PLINT arg6 ;
08870   PLFLT *arg7 = (PLFLT *) 0 ;
08871   PLINT arg8 ;
08872   PyArrayObject *tmp1 = NULL ;
08873   PyArrayObject *tmp2 = NULL ;
08874   PyArrayObject *tmp3 = NULL ;
08875   int val6 ;
08876   int ecode6 = 0 ;
08877   PyArrayObject *tmp7 = NULL ;
08878   PyObject * obj0 = 0 ;
08879   PyObject * obj1 = 0 ;
08880   PyObject * obj2 = 0 ;
08881   PyObject * obj3 = 0 ;
08882   PyObject * obj4 = 0 ;
08883   
08884   if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmeshc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
08885   {
08886     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
08887     if ( tmp1 == NULL )
08888     return NULL;
08889     Xlen = PyArray_DIMS( tmp1 )[0];
08890     arg1   = (PLFLT *) PyArray_DATA( tmp1 );
08891   }
08892   {
08893     tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
08894     if ( tmp2 == NULL )
08895     return NULL;
08896     Ylen = PyArray_DIMS( tmp2 )[0];
08897     arg2   = (PLFLT *) PyArray_DATA( tmp2 );
08898   }
08899   {
08900     int i, size;
08901     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
08902     if ( tmp3 == NULL )
08903     return NULL;
08904     if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
08905     {
08906       PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
08907       return NULL;
08908     }
08909     arg4   = PyArray_DIMS( tmp3 )[0];
08910     arg5   = PyArray_DIMS( tmp3 )[1];
08911     size = arg5;
08912     arg3   = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
08913     for ( i = 0; i < arg4; i++ )
08914     arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
08915   }
08916   ecode6 = SWIG_AsVal_int(obj3, &val6);
08917   if (!SWIG_IsOK(ecode6)) {
08918     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
08919   } 
08920   arg6 = (PLINT)(val6);
08921   {
08922     tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
08923     if ( tmp7 == NULL )
08924     return NULL;
08925     arg8 = PyArray_DIMS( tmp7 )[0];
08926     arg7 = (PLFLT *) PyArray_DATA( tmp7 );
08927   }
08928   plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
08929   resultobj = SWIG_Py_Void();
08930   {
08931     Py_CLEAR( tmp1 );
08932   }
08933   {
08934     Py_CLEAR( tmp2 );
08935   }
08936   {
08937     Py_CLEAR( tmp3 );
08938     free( arg3 );
08939   }
08940   {
08941     Py_CLEAR( tmp7 );
08942   }
08943   return resultobj;
08944 fail:
08945   {
08946     Py_CLEAR( tmp1 );
08947   }
08948   {
08949     Py_CLEAR( tmp2 );
08950   }
08951   {
08952     Py_CLEAR( tmp3 );
08953     free( arg3 );
08954   }
08955   {
08956     Py_CLEAR( tmp7 );
08957   }
08958   return NULL;
08959 }
08960 
08961 
08962 SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08963   PyObject *resultobj = 0;
08964   PLINT *arg1 = (PLINT *) 0 ;
08965   PLINT temp1 ;
08966   int res1 = SWIG_TMPOBJ ;
08967   
08968   arg1 = &temp1;
08969   if (!PyArg_ParseTuple(args,(char *)":plmkstrm")) SWIG_fail;
08970   plmkstrm(arg1);
08971   resultobj = SWIG_Py_Void();
08972   if (SWIG_IsTmpObj(res1)) {
08973     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
08974   } else {
08975     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
08976     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
08977   }
08978   return resultobj;
08979 fail:
08980   return NULL;
08981 }
08982 
08983 
08984 SWIGINTERN PyObject *_wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
08985   PyObject *resultobj = 0;
08986   char *arg1 = (char *) 0 ;
08987   PLFLT arg2 ;
08988   PLFLT arg3 ;
08989   PLFLT arg4 ;
08990   char *arg5 = (char *) 0 ;
08991   int res1 ;
08992   char *buf1 = 0 ;
08993   int alloc1 = 0 ;
08994   double val2 ;
08995   int ecode2 = 0 ;
08996   double val3 ;
08997   int ecode3 = 0 ;
08998   double val4 ;
08999   int ecode4 = 0 ;
09000   int res5 ;
09001   char *buf5 = 0 ;
09002   int alloc5 = 0 ;
09003   PyObject * obj0 = 0 ;
09004   PyObject * obj1 = 0 ;
09005   PyObject * obj2 = 0 ;
09006   PyObject * obj3 = 0 ;
09007   PyObject * obj4 = 0 ;
09008   
09009   if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
09010   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
09011   if (!SWIG_IsOK(res1)) {
09012     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
09013   }
09014   arg1 = (char *)(buf1);
09015   ecode2 = SWIG_AsVal_double(obj1, &val2);
09016   if (!SWIG_IsOK(ecode2)) {
09017     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
09018   } 
09019   arg2 = (PLFLT)(val2);
09020   ecode3 = SWIG_AsVal_double(obj2, &val3);
09021   if (!SWIG_IsOK(ecode3)) {
09022     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
09023   } 
09024   arg3 = (PLFLT)(val3);
09025   ecode4 = SWIG_AsVal_double(obj3, &val4);
09026   if (!SWIG_IsOK(ecode4)) {
09027     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
09028   } 
09029   arg4 = (PLFLT)(val4);
09030   res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
09031   if (!SWIG_IsOK(res5)) {
09032     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
09033   }
09034   arg5 = (char *)(buf5);
09035   plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
09036   resultobj = SWIG_Py_Void();
09037   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
09038   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
09039   return resultobj;
09040 fail:
09041   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
09042   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
09043   return NULL;
09044 }
09045 
09046 
09047 SWIGINTERN PyObject *_wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09048   PyObject *resultobj = 0;
09049   char *arg1 = (char *) 0 ;
09050   PLFLT arg2 ;
09051   PLFLT arg3 ;
09052   PLFLT arg4 ;
09053   char *arg5 = (char *) 0 ;
09054   int res1 ;
09055   char *buf1 = 0 ;
09056   int alloc1 = 0 ;
09057   double val2 ;
09058   int ecode2 = 0 ;
09059   double val3 ;
09060   int ecode3 = 0 ;
09061   double val4 ;
09062   int ecode4 = 0 ;
09063   int res5 ;
09064   char *buf5 = 0 ;
09065   int alloc5 = 0 ;
09066   PyObject * obj0 = 0 ;
09067   PyObject * obj1 = 0 ;
09068   PyObject * obj2 = 0 ;
09069   PyObject * obj3 = 0 ;
09070   PyObject * obj4 = 0 ;
09071   
09072   if (!PyArg_ParseTuple(args,(char *)"OOOOO:plmtex3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
09073   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
09074   if (!SWIG_IsOK(res1)) {
09075     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
09076   }
09077   arg1 = (char *)(buf1);
09078   ecode2 = SWIG_AsVal_double(obj1, &val2);
09079   if (!SWIG_IsOK(ecode2)) {
09080     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
09081   } 
09082   arg2 = (PLFLT)(val2);
09083   ecode3 = SWIG_AsVal_double(obj2, &val3);
09084   if (!SWIG_IsOK(ecode3)) {
09085     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
09086   } 
09087   arg3 = (PLFLT)(val3);
09088   ecode4 = SWIG_AsVal_double(obj3, &val4);
09089   if (!SWIG_IsOK(ecode4)) {
09090     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
09091   } 
09092   arg4 = (PLFLT)(val4);
09093   res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
09094   if (!SWIG_IsOK(res5)) {
09095     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
09096   }
09097   arg5 = (char *)(buf5);
09098   plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
09099   resultobj = SWIG_Py_Void();
09100   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
09101   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
09102   return resultobj;
09103 fail:
09104   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
09105   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
09106   return NULL;
09107 }
09108 
09109 
09110 SWIGINTERN PyObject *_wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09111   PyObject *resultobj = 0;
09112   PLFLT *arg1 = (PLFLT *) 0 ;
09113   PLFLT *arg2 = (PLFLT *) 0 ;
09114   PLFLT **arg3 = (PLFLT **) 0 ;
09115   PLINT arg4 ;
09116   PLINT arg5 ;
09117   PLINT arg6 ;
09118   PLBOOL arg7 ;
09119   PyArrayObject *tmp1 = NULL ;
09120   PyArrayObject *tmp2 = NULL ;
09121   PyArrayObject *tmp3 = NULL ;
09122   int val6 ;
09123   int ecode6 = 0 ;
09124   int val7 ;
09125   int ecode7 = 0 ;
09126   PyObject * obj0 = 0 ;
09127   PyObject * obj1 = 0 ;
09128   PyObject * obj2 = 0 ;
09129   PyObject * obj3 = 0 ;
09130   PyObject * obj4 = 0 ;
09131   
09132   if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
09133   {
09134     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
09135     if ( tmp1 == NULL )
09136     return NULL;
09137     Xlen = PyArray_DIMS( tmp1 )[0];
09138     arg1   = (PLFLT *) PyArray_DATA( tmp1 );
09139   }
09140   {
09141     tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
09142     if ( tmp2 == NULL )
09143     return NULL;
09144     Ylen = PyArray_DIMS( tmp2 )[0];
09145     arg2   = (PLFLT *) PyArray_DATA( tmp2 );
09146   }
09147   {
09148     int i, size;
09149     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
09150     if ( tmp3 == NULL )
09151     return NULL;
09152     if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
09153     {
09154       PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
09155       return NULL;
09156     }
09157     arg4   = PyArray_DIMS( tmp3 )[0];
09158     arg5   = PyArray_DIMS( tmp3 )[1];
09159     size = arg5;
09160     arg3   = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
09161     for ( i = 0; i < arg4; i++ )
09162     arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
09163   }
09164   ecode6 = SWIG_AsVal_int(obj3, &val6);
09165   if (!SWIG_IsOK(ecode6)) {
09166     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
09167   } 
09168   arg6 = (PLINT)(val6);
09169   ecode7 = SWIG_AsVal_int(obj4, &val7);
09170   if (!SWIG_IsOK(ecode7)) {
09171     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
09172   } 
09173   arg7 = (PLBOOL)(val7);
09174   plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
09175   resultobj = SWIG_Py_Void();
09176   {
09177     Py_CLEAR( tmp1 );
09178   }
09179   {
09180     Py_CLEAR( tmp2 );
09181   }
09182   {
09183     Py_CLEAR( tmp3 );
09184     free( arg3 );
09185   }
09186   return resultobj;
09187 fail:
09188   {
09189     Py_CLEAR( tmp1 );
09190   }
09191   {
09192     Py_CLEAR( tmp2 );
09193   }
09194   {
09195     Py_CLEAR( tmp3 );
09196     free( arg3 );
09197   }
09198   return NULL;
09199 }
09200 
09201 
09202 SWIGINTERN PyObject *_wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09203   PyObject *resultobj = 0;
09204   PLFLT *arg1 = (PLFLT *) 0 ;
09205   PLFLT *arg2 = (PLFLT *) 0 ;
09206   PLFLT **arg3 = (PLFLT **) 0 ;
09207   PLINT arg4 ;
09208   PLINT arg5 ;
09209   PLINT arg6 ;
09210   PLFLT *arg7 = (PLFLT *) 0 ;
09211   PLINT arg8 ;
09212   PyArrayObject *tmp1 = NULL ;
09213   PyArrayObject *tmp2 = NULL ;
09214   PyArrayObject *tmp3 = NULL ;
09215   int val6 ;
09216   int ecode6 = 0 ;
09217   PyArrayObject *tmp7 = NULL ;
09218   PyObject * obj0 = 0 ;
09219   PyObject * obj1 = 0 ;
09220   PyObject * obj2 = 0 ;
09221   PyObject * obj3 = 0 ;
09222   PyObject * obj4 = 0 ;
09223   
09224   if (!PyArg_ParseTuple(args,(char *)"OOOOO:plot3dc",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
09225   {
09226     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
09227     if ( tmp1 == NULL )
09228     return NULL;
09229     Xlen = PyArray_DIMS( tmp1 )[0];
09230     arg1   = (PLFLT *) PyArray_DATA( tmp1 );
09231   }
09232   {
09233     tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
09234     if ( tmp2 == NULL )
09235     return NULL;
09236     Ylen = PyArray_DIMS( tmp2 )[0];
09237     arg2   = (PLFLT *) PyArray_DATA( tmp2 );
09238   }
09239   {
09240     int i, size;
09241     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
09242     if ( tmp3 == NULL )
09243     return NULL;
09244     if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
09245     {
09246       PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
09247       return NULL;
09248     }
09249     arg4   = PyArray_DIMS( tmp3 )[0];
09250     arg5   = PyArray_DIMS( tmp3 )[1];
09251     size = arg5;
09252     arg3   = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
09253     for ( i = 0; i < arg4; i++ )
09254     arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
09255   }
09256   ecode6 = SWIG_AsVal_int(obj3, &val6);
09257   if (!SWIG_IsOK(ecode6)) {
09258     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
09259   } 
09260   arg6 = (PLINT)(val6);
09261   {
09262     tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
09263     if ( tmp7 == NULL )
09264     return NULL;
09265     arg8 = PyArray_DIMS( tmp7 )[0];
09266     arg7 = (PLFLT *) PyArray_DATA( tmp7 );
09267   }
09268   plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
09269   resultobj = SWIG_Py_Void();
09270   {
09271     Py_CLEAR( tmp1 );
09272   }
09273   {
09274     Py_CLEAR( tmp2 );
09275   }
09276   {
09277     Py_CLEAR( tmp3 );
09278     free( arg3 );
09279   }
09280   {
09281     Py_CLEAR( tmp7 );
09282   }
09283   return resultobj;
09284 fail:
09285   {
09286     Py_CLEAR( tmp1 );
09287   }
09288   {
09289     Py_CLEAR( tmp2 );
09290   }
09291   {
09292     Py_CLEAR( tmp3 );
09293     free( arg3 );
09294   }
09295   {
09296     Py_CLEAR( tmp7 );
09297   }
09298   return NULL;
09299 }
09300 
09301 
09302 SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09303   PyObject *resultobj = 0;
09304   PLFLT *arg1 = (PLFLT *) 0 ;
09305   PLFLT *arg2 = (PLFLT *) 0 ;
09306   PLFLT **arg3 = (PLFLT **) 0 ;
09307   PLINT arg4 ;
09308   PLINT arg5 ;
09309   PLINT arg6 ;
09310   PLFLT *arg7 = (PLFLT *) 0 ;
09311   PLINT arg8 ;
09312   PLINT arg9 ;
09313   PLINT arg10 ;
09314   PLINT *arg11 = (PLINT *) 0 ;
09315   PLINT *arg12 = (PLINT *) 0 ;
09316   PyArrayObject *tmp1 = NULL ;
09317   PyArrayObject *tmp2 = NULL ;
09318   PyArrayObject *tmp3 = NULL ;
09319   int val6 ;
09320   int ecode6 = 0 ;
09321   PyArrayObject *tmp7 = NULL ;
09322   int val9 ;
09323   int ecode9 = 0 ;
09324   PyArrayObject *tmp10 = NULL ;
09325   PyArrayObject *tmp12 = NULL ;
09326   PyObject * obj0 = 0 ;
09327   PyObject * obj1 = 0 ;
09328   PyObject * obj2 = 0 ;
09329   PyObject * obj3 = 0 ;
09330   PyObject * obj4 = 0 ;
09331   PyObject * obj5 = 0 ;
09332   PyObject * obj6 = 0 ;
09333   PyObject * obj7 = 0 ;
09334   
09335   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plot3dcl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
09336   {
09337     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
09338     if ( tmp1 == NULL )
09339     return NULL;
09340     Xlen = PyArray_DIMS( tmp1 )[0];
09341     arg1   = (PLFLT *) PyArray_DATA( tmp1 );
09342   }
09343   {
09344     tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
09345     if ( tmp2 == NULL )
09346     return NULL;
09347     Ylen = PyArray_DIMS( tmp2 )[0];
09348     arg2   = (PLFLT *) PyArray_DATA( tmp2 );
09349   }
09350   {
09351     int i, size;
09352     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
09353     if ( tmp3 == NULL )
09354     return NULL;
09355     if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
09356     {
09357       PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
09358       return NULL;
09359     }
09360     arg4   = PyArray_DIMS( tmp3 )[0];
09361     arg5   = PyArray_DIMS( tmp3 )[1];
09362     size = arg5;
09363     arg3   = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
09364     for ( i = 0; i < arg4; i++ )
09365     arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
09366   }
09367   ecode6 = SWIG_AsVal_int(obj3, &val6);
09368   if (!SWIG_IsOK(ecode6)) {
09369     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
09370   } 
09371   arg6 = (PLINT)(val6);
09372   {
09373     tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
09374     if ( tmp7 == NULL )
09375     return NULL;
09376     arg8 = PyArray_DIMS( tmp7 )[0];
09377     arg7 = (PLFLT *) PyArray_DATA( tmp7 );
09378   }
09379   ecode9 = SWIG_AsVal_int(obj5, &val9);
09380   if (!SWIG_IsOK(ecode9)) {
09381     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
09382   } 
09383   arg9 = (PLINT)(val9);
09384   {
09385     tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
09386     if ( tmp10 == NULL )
09387     return NULL;
09388     arg10 = Alen = PyArray_DIMS( tmp10 )[0];
09389     arg11 = (PLINT *) PyArray_DATA( tmp10 );
09390   }
09391   {
09392     tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 );
09393     if ( tmp12 == NULL )
09394     return NULL;
09395     if ( PyArray_DIMS( tmp12 )[0] != Alen )
09396     {
09397       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09398       return NULL;
09399     }
09400     arg12 = (PLINT *) PyArray_DATA( tmp12 );
09401   }
09402   plot3dcl((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8,arg9,arg10,(int const *)arg11,(int const *)arg12);
09403   resultobj = SWIG_Py_Void();
09404   {
09405     Py_CLEAR( tmp1 );
09406   }
09407   {
09408     Py_CLEAR( tmp2 );
09409   }
09410   {
09411     Py_CLEAR( tmp3 );
09412     free( arg3 );
09413   }
09414   {
09415     Py_CLEAR( tmp7 );
09416   }
09417   {
09418     Py_CLEAR( tmp10 );
09419   }
09420   {
09421     Py_CLEAR( tmp12 );
09422   }
09423   return resultobj;
09424 fail:
09425   {
09426     Py_CLEAR( tmp1 );
09427   }
09428   {
09429     Py_CLEAR( tmp2 );
09430   }
09431   {
09432     Py_CLEAR( tmp3 );
09433     free( arg3 );
09434   }
09435   {
09436     Py_CLEAR( tmp7 );
09437   }
09438   {
09439     Py_CLEAR( tmp10 );
09440   }
09441   {
09442     Py_CLEAR( tmp12 );
09443   }
09444   return NULL;
09445 }
09446 
09447 
09448 SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09449   PyObject *resultobj = 0;
09450   PLFLT *arg1 = (PLFLT *) 0 ;
09451   PLFLT *arg2 = (PLFLT *) 0 ;
09452   PLFLT **arg3 = (PLFLT **) 0 ;
09453   PLINT arg4 ;
09454   PLINT arg5 ;
09455   PLINT arg6 ;
09456   PLFLT *arg7 = (PLFLT *) 0 ;
09457   PLINT arg8 ;
09458   PyArrayObject *tmp1 = NULL ;
09459   PyArrayObject *tmp2 = NULL ;
09460   PyArrayObject *tmp3 = NULL ;
09461   int val6 ;
09462   int ecode6 = 0 ;
09463   PyArrayObject *tmp7 = NULL ;
09464   PyObject * obj0 = 0 ;
09465   PyObject * obj1 = 0 ;
09466   PyObject * obj2 = 0 ;
09467   PyObject * obj3 = 0 ;
09468   PyObject * obj4 = 0 ;
09469   
09470   if (!PyArg_ParseTuple(args,(char *)"OOOOO:plsurf3d",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
09471   {
09472     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
09473     if ( tmp1 == NULL )
09474     return NULL;
09475     Xlen = PyArray_DIMS( tmp1 )[0];
09476     arg1   = (PLFLT *) PyArray_DATA( tmp1 );
09477   }
09478   {
09479     tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
09480     if ( tmp2 == NULL )
09481     return NULL;
09482     Ylen = PyArray_DIMS( tmp2 )[0];
09483     arg2   = (PLFLT *) PyArray_DATA( tmp2 );
09484   }
09485   {
09486     int i, size;
09487     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
09488     if ( tmp3 == NULL )
09489     return NULL;
09490     if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
09491     {
09492       PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
09493       return NULL;
09494     }
09495     arg4   = PyArray_DIMS( tmp3 )[0];
09496     arg5   = PyArray_DIMS( tmp3 )[1];
09497     size = arg5;
09498     arg3   = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
09499     for ( i = 0; i < arg4; i++ )
09500     arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
09501   }
09502   ecode6 = SWIG_AsVal_int(obj3, &val6);
09503   if (!SWIG_IsOK(ecode6)) {
09504     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
09505   } 
09506   arg6 = (PLINT)(val6);
09507   {
09508     tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
09509     if ( tmp7 == NULL )
09510     return NULL;
09511     arg8 = PyArray_DIMS( tmp7 )[0];
09512     arg7 = (PLFLT *) PyArray_DATA( tmp7 );
09513   }
09514   plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
09515   resultobj = SWIG_Py_Void();
09516   {
09517     Py_CLEAR( tmp1 );
09518   }
09519   {
09520     Py_CLEAR( tmp2 );
09521   }
09522   {
09523     Py_CLEAR( tmp3 );
09524     free( arg3 );
09525   }
09526   {
09527     Py_CLEAR( tmp7 );
09528   }
09529   return resultobj;
09530 fail:
09531   {
09532     Py_CLEAR( tmp1 );
09533   }
09534   {
09535     Py_CLEAR( tmp2 );
09536   }
09537   {
09538     Py_CLEAR( tmp3 );
09539     free( arg3 );
09540   }
09541   {
09542     Py_CLEAR( tmp7 );
09543   }
09544   return NULL;
09545 }
09546 
09547 
09548 SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09549   PyObject *resultobj = 0;
09550   PLFLT *arg1 = (PLFLT *) 0 ;
09551   PLFLT *arg2 = (PLFLT *) 0 ;
09552   PLFLT **arg3 = (PLFLT **) 0 ;
09553   PLINT arg4 ;
09554   PLINT arg5 ;
09555   PLINT arg6 ;
09556   PLFLT *arg7 = (PLFLT *) 0 ;
09557   PLINT arg8 ;
09558   PLINT arg9 ;
09559   PLINT arg10 ;
09560   PLINT *arg11 = (PLINT *) 0 ;
09561   PLINT *arg12 = (PLINT *) 0 ;
09562   PyArrayObject *tmp1 = NULL ;
09563   PyArrayObject *tmp2 = NULL ;
09564   PyArrayObject *tmp3 = NULL ;
09565   int val6 ;
09566   int ecode6 = 0 ;
09567   PyArrayObject *tmp7 = NULL ;
09568   int val9 ;
09569   int ecode9 = 0 ;
09570   PyArrayObject *tmp10 = NULL ;
09571   PyArrayObject *tmp12 = NULL ;
09572   PyObject * obj0 = 0 ;
09573   PyObject * obj1 = 0 ;
09574   PyObject * obj2 = 0 ;
09575   PyObject * obj3 = 0 ;
09576   PyObject * obj4 = 0 ;
09577   PyObject * obj5 = 0 ;
09578   PyObject * obj6 = 0 ;
09579   PyObject * obj7 = 0 ;
09580   
09581   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:plsurf3dl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
09582   {
09583     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
09584     if ( tmp1 == NULL )
09585     return NULL;
09586     Xlen = PyArray_DIMS( tmp1 )[0];
09587     arg1   = (PLFLT *) PyArray_DATA( tmp1 );
09588   }
09589   {
09590     tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
09591     if ( tmp2 == NULL )
09592     return NULL;
09593     Ylen = PyArray_DIMS( tmp2 )[0];
09594     arg2   = (PLFLT *) PyArray_DATA( tmp2 );
09595   }
09596   {
09597     int i, size;
09598     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 2, 2 );
09599     if ( tmp3 == NULL )
09600     return NULL;
09601     if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
09602     {
09603       PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
09604       return NULL;
09605     }
09606     arg4   = PyArray_DIMS( tmp3 )[0];
09607     arg5   = PyArray_DIMS( tmp3 )[1];
09608     size = arg5;
09609     arg3   = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
09610     for ( i = 0; i < arg4; i++ )
09611     arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
09612   }
09613   ecode6 = SWIG_AsVal_int(obj3, &val6);
09614   if (!SWIG_IsOK(ecode6)) {
09615     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
09616   } 
09617   arg6 = (PLINT)(val6);
09618   {
09619     tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
09620     if ( tmp7 == NULL )
09621     return NULL;
09622     arg8 = PyArray_DIMS( tmp7 )[0];
09623     arg7 = (PLFLT *) PyArray_DATA( tmp7 );
09624   }
09625   ecode9 = SWIG_AsVal_int(obj5, &val9);
09626   if (!SWIG_IsOK(ecode9)) {
09627     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
09628   } 
09629   arg9 = (PLINT)(val9);
09630   {
09631     tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
09632     if ( tmp10 == NULL )
09633     return NULL;
09634     arg10 = Alen = PyArray_DIMS( tmp10 )[0];
09635     arg11 = (PLINT *) PyArray_DATA( tmp10 );
09636   }
09637   {
09638     tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj7, NPY_PLINT, 1, 1 );
09639     if ( tmp12 == NULL )
09640     return NULL;
09641     if ( PyArray_DIMS( tmp12 )[0] != Alen )
09642     {
09643       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09644       return NULL;
09645     }
09646     arg12 = (PLINT *) PyArray_DATA( tmp12 );
09647   }
09648   plsurf3dl((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8,arg9,arg10,(int const *)arg11,(int const *)arg12);
09649   resultobj = SWIG_Py_Void();
09650   {
09651     Py_CLEAR( tmp1 );
09652   }
09653   {
09654     Py_CLEAR( tmp2 );
09655   }
09656   {
09657     Py_CLEAR( tmp3 );
09658     free( arg3 );
09659   }
09660   {
09661     Py_CLEAR( tmp7 );
09662   }
09663   {
09664     Py_CLEAR( tmp10 );
09665   }
09666   {
09667     Py_CLEAR( tmp12 );
09668   }
09669   return resultobj;
09670 fail:
09671   {
09672     Py_CLEAR( tmp1 );
09673   }
09674   {
09675     Py_CLEAR( tmp2 );
09676   }
09677   {
09678     Py_CLEAR( tmp3 );
09679     free( arg3 );
09680   }
09681   {
09682     Py_CLEAR( tmp7 );
09683   }
09684   {
09685     Py_CLEAR( tmp10 );
09686   }
09687   {
09688     Py_CLEAR( tmp12 );
09689   }
09690   return NULL;
09691 }
09692 
09693 
09694 SWIGINTERN PyObject *_wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09695   PyObject *resultobj = 0;
09696   int *arg1 = (int *) 0 ;
09697   char **arg2 = (char **) 0 ;
09698   PLINT arg3 ;
09699   int tmp1 ;
09700   int val3 ;
09701   int ecode3 = 0 ;
09702   PyObject * obj0 = 0 ;
09703   PyObject * obj1 = 0 ;
09704   PLINT result;
09705   
09706   if (!PyArg_ParseTuple(args,(char *)"OO:plparseopts",&obj0,&obj1)) SWIG_fail;
09707   {
09708     int i;
09709     if ( !PyList_Check( obj0 ) )
09710     {
09711       PyErr_SetString( PyExc_ValueError, "Expecting a list" );
09712       return NULL;
09713     }
09714     tmp1 = PyList_Size( obj0 );
09715     arg1  = &tmp1;
09716     arg2  = (char **) malloc( (size_t) ( tmp1 + 1 ) * sizeof ( char * ) );
09717     for ( i = 0; i < tmp1; i++ )
09718     {
09719       PyObject *s = PyList_GetItem( obj0, i );
09720       if ( !PyString_Check( s ) )
09721       {
09722         free( arg2 );
09723         PyErr_SetString( PyExc_ValueError, "List items must be strings" );
09724         return NULL;
09725       }
09726       arg2[i] = PyString_AsString( s );
09727     }
09728     arg2[i] = 0;
09729   }
09730   ecode3 = SWIG_AsVal_int(obj1, &val3);
09731   if (!SWIG_IsOK(ecode3)) {
09732     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
09733   } 
09734   arg3 = (PLINT)(val3);
09735   result = (PLINT)plparseopts(arg1,(char const **)arg2,arg3);
09736   resultobj = SWIG_From_int((int)(result));
09737   {
09738     if ( arg2 )
09739     free( arg2 );
09740   }
09741   return resultobj;
09742 fail:
09743   {
09744     if ( arg2 )
09745     free( arg2 );
09746   }
09747   return NULL;
09748 }
09749 
09750 
09751 SWIGINTERN PyObject *_wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09752   PyObject *resultobj = 0;
09753   PLINT arg1 ;
09754   PLINT *arg2 = (PLINT *) 0 ;
09755   PLINT *arg3 = (PLINT *) 0 ;
09756   PyArrayObject *tmp1 = NULL ;
09757   PyArrayObject *tmp3 = NULL ;
09758   PyObject * obj0 = 0 ;
09759   PyObject * obj1 = 0 ;
09760   
09761   if (!PyArg_ParseTuple(args,(char *)"OO:plpat",&obj0,&obj1)) SWIG_fail;
09762   {
09763     tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
09764     if ( tmp1 == NULL )
09765     return NULL;
09766     arg1 = Alen = PyArray_DIMS( tmp1 )[0];
09767     arg2 = (PLINT *) PyArray_DATA( tmp1 );
09768   }
09769   {
09770     tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
09771     if ( tmp3 == NULL )
09772     return NULL;
09773     if ( PyArray_DIMS( tmp3 )[0] != Alen )
09774     {
09775       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09776       return NULL;
09777     }
09778     arg3 = (PLINT *) PyArray_DATA( tmp3 );
09779   }
09780   plpat(arg1,(int const *)arg2,(int const *)arg3);
09781   resultobj = SWIG_Py_Void();
09782   {
09783     Py_CLEAR( tmp1 );
09784   }
09785   {
09786     Py_CLEAR( tmp3 );
09787   }
09788   return resultobj;
09789 fail:
09790   {
09791     Py_CLEAR( tmp1 );
09792   }
09793   {
09794     Py_CLEAR( tmp3 );
09795   }
09796   return NULL;
09797 }
09798 
09799 
09800 SWIGINTERN PyObject *_wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09801   PyObject *resultobj = 0;
09802   PLINT arg1 ;
09803   PLFLT arg2 ;
09804   PLFLT arg3 ;
09805   PLFLT arg4 ;
09806   PLFLT arg5 ;
09807   int val1 ;
09808   int ecode1 = 0 ;
09809   double val2 ;
09810   int ecode2 = 0 ;
09811   double val3 ;
09812   int ecode3 = 0 ;
09813   double val4 ;
09814   int ecode4 = 0 ;
09815   double val5 ;
09816   int ecode5 = 0 ;
09817   PyObject * obj0 = 0 ;
09818   PyObject * obj1 = 0 ;
09819   PyObject * obj2 = 0 ;
09820   PyObject * obj3 = 0 ;
09821   PyObject * obj4 = 0 ;
09822   
09823   if (!PyArg_ParseTuple(args,(char *)"OOOOO:plpath",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
09824   ecode1 = SWIG_AsVal_int(obj0, &val1);
09825   if (!SWIG_IsOK(ecode1)) {
09826     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
09827   } 
09828   arg1 = (PLINT)(val1);
09829   ecode2 = SWIG_AsVal_double(obj1, &val2);
09830   if (!SWIG_IsOK(ecode2)) {
09831     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
09832   } 
09833   arg2 = (PLFLT)(val2);
09834   ecode3 = SWIG_AsVal_double(obj2, &val3);
09835   if (!SWIG_IsOK(ecode3)) {
09836     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
09837   } 
09838   arg3 = (PLFLT)(val3);
09839   ecode4 = SWIG_AsVal_double(obj3, &val4);
09840   if (!SWIG_IsOK(ecode4)) {
09841     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
09842   } 
09843   arg4 = (PLFLT)(val4);
09844   ecode5 = SWIG_AsVal_double(obj4, &val5);
09845   if (!SWIG_IsOK(ecode5)) {
09846     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
09847   } 
09848   arg5 = (PLFLT)(val5);
09849   plpath(arg1,arg2,arg3,arg4,arg5);
09850   resultobj = SWIG_Py_Void();
09851   return resultobj;
09852 fail:
09853   return NULL;
09854 }
09855 
09856 
09857 SWIGINTERN PyObject *_wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09858   PyObject *resultobj = 0;
09859   PLINT arg1 ;
09860   PLFLT *arg2 = (PLFLT *) 0 ;
09861   PLFLT *arg3 = (PLFLT *) 0 ;
09862   PLINT arg4 ;
09863   PyArrayObject *tmp1 = NULL ;
09864   PyArrayObject *tmp3 = NULL ;
09865   int val4 ;
09866   int ecode4 = 0 ;
09867   PyObject * obj0 = 0 ;
09868   PyObject * obj1 = 0 ;
09869   PyObject * obj2 = 0 ;
09870   
09871   if (!PyArg_ParseTuple(args,(char *)"OOO:plpoin",&obj0,&obj1,&obj2)) SWIG_fail;
09872   {
09873     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
09874     if ( tmp1 == NULL )
09875     return NULL;
09876     arg1 = Alen = PyArray_DIMS( tmp1 )[0];
09877     arg2 = (PLFLT *) PyArray_DATA( tmp1 );
09878   }
09879   {
09880     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
09881     if ( tmp3 == NULL )
09882     return NULL;
09883     if ( PyArray_DIMS( tmp3 )[0] != Alen )
09884     {
09885       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09886       return NULL;
09887     }
09888     arg3 = (PLFLT *) PyArray_DATA( tmp3 );
09889   }
09890   ecode4 = SWIG_AsVal_int(obj2, &val4);
09891   if (!SWIG_IsOK(ecode4)) {
09892     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
09893   } 
09894   arg4 = (PLINT)(val4);
09895   plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
09896   resultobj = SWIG_Py_Void();
09897   {
09898     Py_CLEAR( tmp1 );
09899   }
09900   {
09901     Py_CLEAR( tmp3 );
09902   }
09903   return resultobj;
09904 fail:
09905   {
09906     Py_CLEAR( tmp1 );
09907   }
09908   {
09909     Py_CLEAR( tmp3 );
09910   }
09911   return NULL;
09912 }
09913 
09914 
09915 SWIGINTERN PyObject *_wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09916   PyObject *resultobj = 0;
09917   PLINT arg1 ;
09918   PLFLT *arg2 = (PLFLT *) 0 ;
09919   PLFLT *arg3 = (PLFLT *) 0 ;
09920   PLFLT *arg4 = (PLFLT *) 0 ;
09921   PLINT arg5 ;
09922   PyArrayObject *tmp1 = NULL ;
09923   PyArrayObject *tmp3 = NULL ;
09924   PyArrayObject *tmp4 = NULL ;
09925   int val5 ;
09926   int ecode5 = 0 ;
09927   PyObject * obj0 = 0 ;
09928   PyObject * obj1 = 0 ;
09929   PyObject * obj2 = 0 ;
09930   PyObject * obj3 = 0 ;
09931   
09932   if (!PyArg_ParseTuple(args,(char *)"OOOO:plpoin3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
09933   {
09934     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
09935     if ( tmp1 == NULL )
09936     return NULL;
09937     arg1 = Alen = PyArray_DIMS( tmp1 )[0];
09938     arg2 = (PLFLT *) PyArray_DATA( tmp1 );
09939   }
09940   {
09941     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
09942     if ( tmp3 == NULL )
09943     return NULL;
09944     if ( PyArray_DIMS( tmp3 )[0] != Alen )
09945     {
09946       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09947       return NULL;
09948     }
09949     arg3 = (PLFLT *) PyArray_DATA( tmp3 );
09950   }
09951   {
09952     tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
09953     if ( tmp4 == NULL )
09954     return NULL;
09955     if ( PyArray_DIMS( tmp4 )[0] != Alen )
09956     {
09957       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
09958       return NULL;
09959     }
09960     arg4 = (PLFLT *) PyArray_DATA( tmp4 );
09961   }
09962   ecode5 = SWIG_AsVal_int(obj3, &val5);
09963   if (!SWIG_IsOK(ecode5)) {
09964     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
09965   } 
09966   arg5 = (PLINT)(val5);
09967   plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
09968   resultobj = SWIG_Py_Void();
09969   {
09970     Py_CLEAR( tmp1 );
09971   }
09972   {
09973     Py_CLEAR( tmp3 );
09974   }
09975   {
09976     Py_CLEAR( tmp4 );
09977   }
09978   return resultobj;
09979 fail:
09980   {
09981     Py_CLEAR( tmp1 );
09982   }
09983   {
09984     Py_CLEAR( tmp3 );
09985   }
09986   {
09987     Py_CLEAR( tmp4 );
09988   }
09989   return NULL;
09990 }
09991 
09992 
09993 SWIGINTERN PyObject *_wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
09994   PyObject *resultobj = 0;
09995   PLINT arg1 ;
09996   PLFLT *arg2 = (PLFLT *) 0 ;
09997   PLFLT *arg3 = (PLFLT *) 0 ;
09998   PLFLT *arg4 = (PLFLT *) 0 ;
09999   PLBOOL *arg5 = (PLBOOL *) 0 ;
10000   PLBOOL arg6 ;
10001   PyArrayObject *tmp1 = NULL ;
10002   PyArrayObject *tmp3 = NULL ;
10003   PyArrayObject *tmp4 = NULL ;
10004   PyArrayObject *tmp5 = NULL ;
10005   int val6 ;
10006   int ecode6 = 0 ;
10007   PyObject * obj0 = 0 ;
10008   PyObject * obj1 = 0 ;
10009   PyObject * obj2 = 0 ;
10010   PyObject * obj3 = 0 ;
10011   PyObject * obj4 = 0 ;
10012   
10013   if (!PyArg_ParseTuple(args,(char *)"OOOOO:plpoly3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
10014   {
10015     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
10016     if ( tmp1 == NULL )
10017     return NULL;
10018     arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10019     arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10020   }
10021   {
10022     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10023     if ( tmp3 == NULL )
10024     return NULL;
10025     if ( PyArray_DIMS( tmp3 )[0] != Alen )
10026     {
10027       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10028       return NULL;
10029     }
10030     arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10031   }
10032   {
10033     tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10034     if ( tmp4 == NULL )
10035     return NULL;
10036     if ( PyArray_DIMS( tmp4 )[0] != Alen )
10037     {
10038       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10039       return NULL;
10040     }
10041     arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10042   }
10043   {
10044     tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj3, NPY_PLINT, 1, 1 );
10045     if ( tmp5 == NULL )
10046     return NULL;
10047     if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
10048     {
10049       PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10050       return NULL;
10051     }
10052     arg5 = (PLINT *) PyArray_DATA( tmp5 );
10053   }
10054   ecode6 = SWIG_AsVal_int(obj4, &val6);
10055   if (!SWIG_IsOK(ecode6)) {
10056     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
10057   } 
10058   arg6 = (PLBOOL)(val6);
10059   plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
10060   resultobj = SWIG_Py_Void();
10061   {
10062     Py_CLEAR( tmp1 );
10063   }
10064   {
10065     Py_CLEAR( tmp3 );
10066   }
10067   {
10068     Py_CLEAR( tmp4 );
10069   }
10070   {
10071     Py_CLEAR( tmp5 );
10072   }
10073   return resultobj;
10074 fail:
10075   {
10076     Py_CLEAR( tmp1 );
10077   }
10078   {
10079     Py_CLEAR( tmp3 );
10080   }
10081   {
10082     Py_CLEAR( tmp4 );
10083   }
10084   {
10085     Py_CLEAR( tmp5 );
10086   }
10087   return NULL;
10088 }
10089 
10090 
10091 SWIGINTERN PyObject *_wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10092   PyObject *resultobj = 0;
10093   PLINT arg1 ;
10094   PLINT arg2 ;
10095   int val1 ;
10096   int ecode1 = 0 ;
10097   int val2 ;
10098   int ecode2 = 0 ;
10099   PyObject * obj0 = 0 ;
10100   PyObject * obj1 = 0 ;
10101   
10102   if (!PyArg_ParseTuple(args,(char *)"OO:plprec",&obj0,&obj1)) SWIG_fail;
10103   ecode1 = SWIG_AsVal_int(obj0, &val1);
10104   if (!SWIG_IsOK(ecode1)) {
10105     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
10106   } 
10107   arg1 = (PLINT)(val1);
10108   ecode2 = SWIG_AsVal_int(obj1, &val2);
10109   if (!SWIG_IsOK(ecode2)) {
10110     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
10111   } 
10112   arg2 = (PLINT)(val2);
10113   plprec(arg1,arg2);
10114   resultobj = SWIG_Py_Void();
10115   return resultobj;
10116 fail:
10117   return NULL;
10118 }
10119 
10120 
10121 SWIGINTERN PyObject *_wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10122   PyObject *resultobj = 0;
10123   PLINT arg1 ;
10124   int val1 ;
10125   int ecode1 = 0 ;
10126   PyObject * obj0 = 0 ;
10127   
10128   if (!PyArg_ParseTuple(args,(char *)"O:plpsty",&obj0)) SWIG_fail;
10129   ecode1 = SWIG_AsVal_int(obj0, &val1);
10130   if (!SWIG_IsOK(ecode1)) {
10131     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
10132   } 
10133   arg1 = (PLINT)(val1);
10134   plpsty(arg1);
10135   resultobj = SWIG_Py_Void();
10136   return resultobj;
10137 fail:
10138   return NULL;
10139 }
10140 
10141 
10142 SWIGINTERN PyObject *_wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10143   PyObject *resultobj = 0;
10144   PLFLT arg1 ;
10145   PLFLT arg2 ;
10146   PLFLT arg3 ;
10147   PLFLT arg4 ;
10148   PLFLT arg5 ;
10149   char *arg6 = (char *) 0 ;
10150   double val1 ;
10151   int ecode1 = 0 ;
10152   double val2 ;
10153   int ecode2 = 0 ;
10154   double val3 ;
10155   int ecode3 = 0 ;
10156   double val4 ;
10157   int ecode4 = 0 ;
10158   double val5 ;
10159   int ecode5 = 0 ;
10160   int res6 ;
10161   char *buf6 = 0 ;
10162   int alloc6 = 0 ;
10163   PyObject * obj0 = 0 ;
10164   PyObject * obj1 = 0 ;
10165   PyObject * obj2 = 0 ;
10166   PyObject * obj3 = 0 ;
10167   PyObject * obj4 = 0 ;
10168   PyObject * obj5 = 0 ;
10169   
10170   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plptex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10171   ecode1 = SWIG_AsVal_double(obj0, &val1);
10172   if (!SWIG_IsOK(ecode1)) {
10173     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
10174   } 
10175   arg1 = (PLFLT)(val1);
10176   ecode2 = SWIG_AsVal_double(obj1, &val2);
10177   if (!SWIG_IsOK(ecode2)) {
10178     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
10179   } 
10180   arg2 = (PLFLT)(val2);
10181   ecode3 = SWIG_AsVal_double(obj2, &val3);
10182   if (!SWIG_IsOK(ecode3)) {
10183     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
10184   } 
10185   arg3 = (PLFLT)(val3);
10186   ecode4 = SWIG_AsVal_double(obj3, &val4);
10187   if (!SWIG_IsOK(ecode4)) {
10188     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
10189   } 
10190   arg4 = (PLFLT)(val4);
10191   ecode5 = SWIG_AsVal_double(obj4, &val5);
10192   if (!SWIG_IsOK(ecode5)) {
10193     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
10194   } 
10195   arg5 = (PLFLT)(val5);
10196   res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
10197   if (!SWIG_IsOK(res6)) {
10198     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
10199   }
10200   arg6 = (char *)(buf6);
10201   plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
10202   resultobj = SWIG_Py_Void();
10203   if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10204   return resultobj;
10205 fail:
10206   if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10207   return NULL;
10208 }
10209 
10210 
10211 SWIGINTERN PyObject *_wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10212   PyObject *resultobj = 0;
10213   PLFLT arg1 ;
10214   PLFLT arg2 ;
10215   PLFLT arg3 ;
10216   PLFLT arg4 ;
10217   PLFLT arg5 ;
10218   PLFLT arg6 ;
10219   PLFLT arg7 ;
10220   PLFLT arg8 ;
10221   PLFLT arg9 ;
10222   PLFLT arg10 ;
10223   char *arg11 = (char *) 0 ;
10224   double val1 ;
10225   int ecode1 = 0 ;
10226   double val2 ;
10227   int ecode2 = 0 ;
10228   double val3 ;
10229   int ecode3 = 0 ;
10230   double val4 ;
10231   int ecode4 = 0 ;
10232   double val5 ;
10233   int ecode5 = 0 ;
10234   double val6 ;
10235   int ecode6 = 0 ;
10236   double val7 ;
10237   int ecode7 = 0 ;
10238   double val8 ;
10239   int ecode8 = 0 ;
10240   double val9 ;
10241   int ecode9 = 0 ;
10242   double val10 ;
10243   int ecode10 = 0 ;
10244   int res11 ;
10245   char *buf11 = 0 ;
10246   int alloc11 = 0 ;
10247   PyObject * obj0 = 0 ;
10248   PyObject * obj1 = 0 ;
10249   PyObject * obj2 = 0 ;
10250   PyObject * obj3 = 0 ;
10251   PyObject * obj4 = 0 ;
10252   PyObject * obj5 = 0 ;
10253   PyObject * obj6 = 0 ;
10254   PyObject * obj7 = 0 ;
10255   PyObject * obj8 = 0 ;
10256   PyObject * obj9 = 0 ;
10257   PyObject * obj10 = 0 ;
10258   
10259   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plptex3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
10260   ecode1 = SWIG_AsVal_double(obj0, &val1);
10261   if (!SWIG_IsOK(ecode1)) {
10262     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
10263   } 
10264   arg1 = (PLFLT)(val1);
10265   ecode2 = SWIG_AsVal_double(obj1, &val2);
10266   if (!SWIG_IsOK(ecode2)) {
10267     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
10268   } 
10269   arg2 = (PLFLT)(val2);
10270   ecode3 = SWIG_AsVal_double(obj2, &val3);
10271   if (!SWIG_IsOK(ecode3)) {
10272     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
10273   } 
10274   arg3 = (PLFLT)(val3);
10275   ecode4 = SWIG_AsVal_double(obj3, &val4);
10276   if (!SWIG_IsOK(ecode4)) {
10277     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
10278   } 
10279   arg4 = (PLFLT)(val4);
10280   ecode5 = SWIG_AsVal_double(obj4, &val5);
10281   if (!SWIG_IsOK(ecode5)) {
10282     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
10283   } 
10284   arg5 = (PLFLT)(val5);
10285   ecode6 = SWIG_AsVal_double(obj5, &val6);
10286   if (!SWIG_IsOK(ecode6)) {
10287     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
10288   } 
10289   arg6 = (PLFLT)(val6);
10290   ecode7 = SWIG_AsVal_double(obj6, &val7);
10291   if (!SWIG_IsOK(ecode7)) {
10292     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
10293   } 
10294   arg7 = (PLFLT)(val7);
10295   ecode8 = SWIG_AsVal_double(obj7, &val8);
10296   if (!SWIG_IsOK(ecode8)) {
10297     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
10298   } 
10299   arg8 = (PLFLT)(val8);
10300   ecode9 = SWIG_AsVal_double(obj8, &val9);
10301   if (!SWIG_IsOK(ecode9)) {
10302     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
10303   } 
10304   arg9 = (PLFLT)(val9);
10305   ecode10 = SWIG_AsVal_double(obj9, &val10);
10306   if (!SWIG_IsOK(ecode10)) {
10307     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
10308   } 
10309   arg10 = (PLFLT)(val10);
10310   res11 = SWIG_AsCharPtrAndSize(obj10, &buf11, NULL, &alloc11);
10311   if (!SWIG_IsOK(res11)) {
10312     SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
10313   }
10314   arg11 = (char *)(buf11);
10315   plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
10316   resultobj = SWIG_Py_Void();
10317   if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10318   return resultobj;
10319 fail:
10320   if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10321   return NULL;
10322 }
10323 
10324 
10325 SWIGINTERN PyObject *_wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10326   PyObject *resultobj = 0;
10327   PLFLT result;
10328   
10329   if (!PyArg_ParseTuple(args,(char *)":plrandd")) SWIG_fail;
10330   result = (PLFLT)plrandd();
10331   resultobj = SWIG_From_double((double)(result));
10332   return resultobj;
10333 fail:
10334   return NULL;
10335 }
10336 
10337 
10338 SWIGINTERN PyObject *_wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10339   PyObject *resultobj = 0;
10340   
10341   if (!PyArg_ParseTuple(args,(char *)":plreplot")) SWIG_fail;
10342   plreplot();
10343   resultobj = SWIG_Py_Void();
10344   return resultobj;
10345 fail:
10346   return NULL;
10347 }
10348 
10349 
10350 SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10351   PyObject *resultobj = 0;
10352   PLFLT arg1 ;
10353   PLFLT arg2 ;
10354   PLFLT arg3 ;
10355   PLFLT *arg4 = (PLFLT *) 0 ;
10356   PLFLT *arg5 = (PLFLT *) 0 ;
10357   PLFLT *arg6 = (PLFLT *) 0 ;
10358   double val1 ;
10359   int ecode1 = 0 ;
10360   double val2 ;
10361   int ecode2 = 0 ;
10362   double val3 ;
10363   int ecode3 = 0 ;
10364   PLFLT temp4 ;
10365   int res4 = SWIG_TMPOBJ ;
10366   PLFLT temp5 ;
10367   int res5 = SWIG_TMPOBJ ;
10368   PLFLT temp6 ;
10369   int res6 = SWIG_TMPOBJ ;
10370   PyObject * obj0 = 0 ;
10371   PyObject * obj1 = 0 ;
10372   PyObject * obj2 = 0 ;
10373   
10374   arg4 = &temp4;
10375   arg5 = &temp5;
10376   arg6 = &temp6;
10377   if (!PyArg_ParseTuple(args,(char *)"OOO:plrgbhls",&obj0,&obj1,&obj2)) SWIG_fail;
10378   ecode1 = SWIG_AsVal_double(obj0, &val1);
10379   if (!SWIG_IsOK(ecode1)) {
10380     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
10381   } 
10382   arg1 = (PLFLT)(val1);
10383   ecode2 = SWIG_AsVal_double(obj1, &val2);
10384   if (!SWIG_IsOK(ecode2)) {
10385     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
10386   } 
10387   arg2 = (PLFLT)(val2);
10388   ecode3 = SWIG_AsVal_double(obj2, &val3);
10389   if (!SWIG_IsOK(ecode3)) {
10390     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
10391   } 
10392   arg3 = (PLFLT)(val3);
10393   plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
10394   resultobj = SWIG_Py_Void();
10395   if (SWIG_IsTmpObj(res4)) {
10396     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
10397   } else {
10398     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
10399     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
10400   }
10401   if (SWIG_IsTmpObj(res5)) {
10402     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
10403   } else {
10404     int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
10405     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
10406   }
10407   if (SWIG_IsTmpObj(res6)) {
10408     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
10409   } else {
10410     int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
10411     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
10412   }
10413   return resultobj;
10414 fail:
10415   return NULL;
10416 }
10417 
10418 
10419 SWIGINTERN PyObject *_wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10420   PyObject *resultobj = 0;
10421   PLFLT arg1 ;
10422   PLFLT arg2 ;
10423   double val1 ;
10424   int ecode1 = 0 ;
10425   double val2 ;
10426   int ecode2 = 0 ;
10427   PyObject * obj0 = 0 ;
10428   PyObject * obj1 = 0 ;
10429   
10430   if (!PyArg_ParseTuple(args,(char *)"OO:plschr",&obj0,&obj1)) SWIG_fail;
10431   ecode1 = SWIG_AsVal_double(obj0, &val1);
10432   if (!SWIG_IsOK(ecode1)) {
10433     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
10434   } 
10435   arg1 = (PLFLT)(val1);
10436   ecode2 = SWIG_AsVal_double(obj1, &val2);
10437   if (!SWIG_IsOK(ecode2)) {
10438     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
10439   } 
10440   arg2 = (PLFLT)(val2);
10441   plschr(arg1,arg2);
10442   resultobj = SWIG_Py_Void();
10443   return resultobj;
10444 fail:
10445   return NULL;
10446 }
10447 
10448 
10449 SWIGINTERN PyObject *_wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10450   PyObject *resultobj = 0;
10451   PLINT *arg1 = (PLINT *) 0 ;
10452   PLINT *arg2 = (PLINT *) 0 ;
10453   PLINT *arg3 = (PLINT *) 0 ;
10454   PLINT arg4 ;
10455   PyArrayObject *tmp1 = NULL ;
10456   PyArrayObject *tmp2 = NULL ;
10457   PyArrayObject *tmp3 = NULL ;
10458   PyObject * obj0 = 0 ;
10459   PyObject * obj1 = 0 ;
10460   PyObject * obj2 = 0 ;
10461   
10462   if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap0",&obj0,&obj1,&obj2)) SWIG_fail;
10463   {
10464     tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10465     if ( tmp1 == NULL )
10466     return NULL;
10467     Alen = PyArray_DIMS( tmp1 )[0];
10468     arg1   = (PLINT *) PyArray_DATA( tmp1 );
10469   }
10470   {
10471     tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10472     if ( tmp2 == NULL )
10473     return NULL;
10474     if ( PyArray_DIMS( tmp2 )[0] != Alen )
10475     {
10476       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10477       return NULL;
10478     }
10479     arg2 = (PLINT *) PyArray_DATA( tmp2 );
10480   }
10481   {
10482     tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10483     if ( tmp3 == NULL )
10484     return NULL;
10485     if ( PyArray_DIMS( tmp3 )[0] != Alen )
10486     {
10487       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10488       return NULL;
10489     }
10490     arg4 = PyArray_DIMS( tmp3 )[0];
10491     arg3 = (PLINT *) PyArray_DATA( tmp3 );
10492   }
10493   plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10494   resultobj = SWIG_Py_Void();
10495   {
10496     Py_CLEAR( tmp1 );
10497   }
10498   {
10499     Py_CLEAR( tmp2 );
10500   }
10501   {
10502     Py_CLEAR( tmp3 );
10503   }
10504   return resultobj;
10505 fail:
10506   {
10507     Py_CLEAR( tmp1 );
10508   }
10509   {
10510     Py_CLEAR( tmp2 );
10511   }
10512   {
10513     Py_CLEAR( tmp3 );
10514   }
10515   return NULL;
10516 }
10517 
10518 
10519 SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10520   PyObject *resultobj = 0;
10521   PLINT *arg1 = (PLINT *) 0 ;
10522   PLINT *arg2 = (PLINT *) 0 ;
10523   PLINT *arg3 = (PLINT *) 0 ;
10524   PLFLT *arg4 = (PLFLT *) 0 ;
10525   PLINT arg5 ;
10526   PyArrayObject *tmp1 = NULL ;
10527   PyArrayObject *tmp2 = NULL ;
10528   PyArrayObject *tmp3 = NULL ;
10529   PyArrayObject *tmp4 = NULL ;
10530   PyObject * obj0 = 0 ;
10531   PyObject * obj1 = 0 ;
10532   PyObject * obj2 = 0 ;
10533   PyObject * obj3 = 0 ;
10534   
10535   if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap0a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10536   {
10537     tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10538     if ( tmp1 == NULL )
10539     return NULL;
10540     Alen = PyArray_DIMS( tmp1 )[0];
10541     arg1   = (PLINT *) PyArray_DATA( tmp1 );
10542   }
10543   {
10544     tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10545     if ( tmp2 == NULL )
10546     return NULL;
10547     if ( PyArray_DIMS( tmp2 )[0] != Alen )
10548     {
10549       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10550       return NULL;
10551     }
10552     arg2 = (PLINT *) PyArray_DATA( tmp2 );
10553   }
10554   {
10555     tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10556     if ( tmp3 == NULL )
10557     return NULL;
10558     if ( PyArray_DIMS( tmp3 )[0] != Alen )
10559     {
10560       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10561       return NULL;
10562     }
10563     arg3 = (PLINT *) PyArray_DATA( tmp3 );
10564   }
10565   {
10566     tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10567     if ( tmp4 == NULL )
10568     return NULL;
10569     if ( PyArray_DIMS( tmp4 )[0] != Alen )
10570     {
10571       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10572       return NULL;
10573     }
10574     arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10575     arg5 = PyArray_DIMS( tmp4 )[0];
10576   }
10577   plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10578   resultobj = SWIG_Py_Void();
10579   {
10580     Py_CLEAR( tmp1 );
10581   }
10582   {
10583     Py_CLEAR( tmp2 );
10584   }
10585   {
10586     Py_CLEAR( tmp3 );
10587   }
10588   {
10589     Py_CLEAR( tmp4 );
10590   }
10591   return resultobj;
10592 fail:
10593   {
10594     Py_CLEAR( tmp1 );
10595   }
10596   {
10597     Py_CLEAR( tmp2 );
10598   }
10599   {
10600     Py_CLEAR( tmp3 );
10601   }
10602   {
10603     Py_CLEAR( tmp4 );
10604   }
10605   return NULL;
10606 }
10607 
10608 
10609 SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10610   PyObject *resultobj = 0;
10611   PLINT arg1 ;
10612   int val1 ;
10613   int ecode1 = 0 ;
10614   PyObject * obj0 = 0 ;
10615   
10616   if (!PyArg_ParseTuple(args,(char *)"O:plscmap0n",&obj0)) SWIG_fail;
10617   ecode1 = SWIG_AsVal_int(obj0, &val1);
10618   if (!SWIG_IsOK(ecode1)) {
10619     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
10620   } 
10621   arg1 = (PLINT)(val1);
10622   plscmap0n(arg1);
10623   resultobj = SWIG_Py_Void();
10624   return resultobj;
10625 fail:
10626   return NULL;
10627 }
10628 
10629 
10630 SWIGINTERN PyObject *_wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10631   PyObject *resultobj = 0;
10632   PLINT *arg1 = (PLINT *) 0 ;
10633   PLINT *arg2 = (PLINT *) 0 ;
10634   PLINT *arg3 = (PLINT *) 0 ;
10635   PLINT arg4 ;
10636   PyArrayObject *tmp1 = NULL ;
10637   PyArrayObject *tmp2 = NULL ;
10638   PyArrayObject *tmp3 = NULL ;
10639   PyObject * obj0 = 0 ;
10640   PyObject * obj1 = 0 ;
10641   PyObject * obj2 = 0 ;
10642   
10643   if (!PyArg_ParseTuple(args,(char *)"OOO:plscmap1",&obj0,&obj1,&obj2)) SWIG_fail;
10644   {
10645     tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10646     if ( tmp1 == NULL )
10647     return NULL;
10648     Alen = PyArray_DIMS( tmp1 )[0];
10649     arg1   = (PLINT *) PyArray_DATA( tmp1 );
10650   }
10651   {
10652     tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10653     if ( tmp2 == NULL )
10654     return NULL;
10655     if ( PyArray_DIMS( tmp2 )[0] != Alen )
10656     {
10657       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10658       return NULL;
10659     }
10660     arg2 = (PLINT *) PyArray_DATA( tmp2 );
10661   }
10662   {
10663     tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10664     if ( tmp3 == NULL )
10665     return NULL;
10666     if ( PyArray_DIMS( tmp3 )[0] != Alen )
10667     {
10668       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10669       return NULL;
10670     }
10671     arg4 = PyArray_DIMS( tmp3 )[0];
10672     arg3 = (PLINT *) PyArray_DATA( tmp3 );
10673   }
10674   plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10675   resultobj = SWIG_Py_Void();
10676   {
10677     Py_CLEAR( tmp1 );
10678   }
10679   {
10680     Py_CLEAR( tmp2 );
10681   }
10682   {
10683     Py_CLEAR( tmp3 );
10684   }
10685   return resultobj;
10686 fail:
10687   {
10688     Py_CLEAR( tmp1 );
10689   }
10690   {
10691     Py_CLEAR( tmp2 );
10692   }
10693   {
10694     Py_CLEAR( tmp3 );
10695   }
10696   return NULL;
10697 }
10698 
10699 
10700 SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10701   PyObject *resultobj = 0;
10702   PLINT *arg1 = (PLINT *) 0 ;
10703   PLINT *arg2 = (PLINT *) 0 ;
10704   PLINT *arg3 = (PLINT *) 0 ;
10705   PLFLT *arg4 = (PLFLT *) 0 ;
10706   PLINT arg5 ;
10707   PyArrayObject *tmp1 = NULL ;
10708   PyArrayObject *tmp2 = NULL ;
10709   PyArrayObject *tmp3 = NULL ;
10710   PyArrayObject *tmp4 = NULL ;
10711   PyObject * obj0 = 0 ;
10712   PyObject * obj1 = 0 ;
10713   PyObject * obj2 = 0 ;
10714   PyObject * obj3 = 0 ;
10715   
10716   if (!PyArg_ParseTuple(args,(char *)"OOOO:plscmap1a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10717   {
10718     tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
10719     if ( tmp1 == NULL )
10720     return NULL;
10721     Alen = PyArray_DIMS( tmp1 )[0];
10722     arg1   = (PLINT *) PyArray_DATA( tmp1 );
10723   }
10724   {
10725     tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
10726     if ( tmp2 == NULL )
10727     return NULL;
10728     if ( PyArray_DIMS( tmp2 )[0] != Alen )
10729     {
10730       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10731       return NULL;
10732     }
10733     arg2 = (PLINT *) PyArray_DATA( tmp2 );
10734   }
10735   {
10736     tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj2, NPY_PLINT, 1, 1 );
10737     if ( tmp3 == NULL )
10738     return NULL;
10739     if ( PyArray_DIMS( tmp3 )[0] != Alen )
10740     {
10741       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10742       return NULL;
10743     }
10744     arg3 = (PLINT *) PyArray_DATA( tmp3 );
10745   }
10746   {
10747     tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10748     if ( tmp4 == NULL )
10749     return NULL;
10750     if ( PyArray_DIMS( tmp4 )[0] != Alen )
10751     {
10752       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10753       return NULL;
10754     }
10755     arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10756     arg5 = PyArray_DIMS( tmp4 )[0];
10757   }
10758   plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10759   resultobj = SWIG_Py_Void();
10760   {
10761     Py_CLEAR( tmp1 );
10762   }
10763   {
10764     Py_CLEAR( tmp2 );
10765   }
10766   {
10767     Py_CLEAR( tmp3 );
10768   }
10769   {
10770     Py_CLEAR( tmp4 );
10771   }
10772   return resultobj;
10773 fail:
10774   {
10775     Py_CLEAR( tmp1 );
10776   }
10777   {
10778     Py_CLEAR( tmp2 );
10779   }
10780   {
10781     Py_CLEAR( tmp3 );
10782   }
10783   {
10784     Py_CLEAR( tmp4 );
10785   }
10786   return NULL;
10787 }
10788 
10789 
10790 SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10791   PyObject *resultobj = 0;
10792   PLBOOL arg1 ;
10793   PLINT arg2 ;
10794   PLFLT *arg3 = (PLFLT *) 0 ;
10795   PLFLT *arg4 = (PLFLT *) 0 ;
10796   PLFLT *arg5 = (PLFLT *) 0 ;
10797   PLFLT *arg6 = (PLFLT *) 0 ;
10798   PLBOOL *arg7 = (PLBOOL *) 0 ;
10799   int val1 ;
10800   int ecode1 = 0 ;
10801   PyArrayObject *tmp2 = NULL ;
10802   PyArrayObject *tmp4 = NULL ;
10803   PyArrayObject *tmp5 = NULL ;
10804   PyArrayObject *tmp6 = NULL ;
10805   PyArrayObject *tmp7 = NULL ;
10806   PyObject * obj0 = 0 ;
10807   PyObject * obj1 = 0 ;
10808   PyObject * obj2 = 0 ;
10809   PyObject * obj3 = 0 ;
10810   PyObject * obj4 = 0 ;
10811   PyObject * obj5 = 0 ;
10812   
10813   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plscmap1l",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10814   ecode1 = SWIG_AsVal_int(obj0, &val1);
10815   if (!SWIG_IsOK(ecode1)) {
10816     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
10817   } 
10818   arg1 = (PLBOOL)(val1);
10819   {
10820     tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10821     if ( tmp2 == NULL )
10822     return NULL;
10823     arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10824     arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10825   }
10826   {
10827     tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10828     if ( tmp4 == NULL )
10829     return NULL;
10830     if ( PyArray_DIMS( tmp4 )[0] != Alen )
10831     {
10832       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10833       return NULL;
10834     }
10835     arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10836   }
10837   {
10838     tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10839     if ( tmp5 == NULL )
10840     return NULL;
10841     if ( PyArray_DIMS( tmp5 )[0] != Alen )
10842     {
10843       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10844       return NULL;
10845     }
10846     arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10847   }
10848   {
10849     tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
10850     if ( tmp6 == NULL )
10851     return NULL;
10852     if ( PyArray_DIMS( tmp6 )[0] != Alen )
10853     {
10854       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10855       return NULL;
10856     }
10857     arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10858   }
10859   {
10860     tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj5, NPY_PLINT, 1, 1 );
10861     if ( tmp7 == NULL )
10862     return NULL;
10863     if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
10864     {
10865       PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10866       return NULL;
10867     }
10868     arg7 = (PLINT *) PyArray_DATA( tmp7 );
10869   }
10870   plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
10871   resultobj = SWIG_Py_Void();
10872   {
10873     Py_CLEAR( tmp2 );
10874   }
10875   {
10876     Py_CLEAR( tmp4 );
10877   }
10878   {
10879     Py_CLEAR( tmp5 );
10880   }
10881   {
10882     Py_CLEAR( tmp6 );
10883   }
10884   {
10885     Py_CLEAR( tmp7 );
10886   }
10887   return resultobj;
10888 fail:
10889   {
10890     Py_CLEAR( tmp2 );
10891   }
10892   {
10893     Py_CLEAR( tmp4 );
10894   }
10895   {
10896     Py_CLEAR( tmp5 );
10897   }
10898   {
10899     Py_CLEAR( tmp6 );
10900   }
10901   {
10902     Py_CLEAR( tmp7 );
10903   }
10904   return NULL;
10905 }
10906 
10907 
10908 SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10909   PyObject *resultobj = 0;
10910   PLBOOL arg1 ;
10911   PLINT arg2 ;
10912   PLFLT *arg3 = (PLFLT *) 0 ;
10913   PLFLT *arg4 = (PLFLT *) 0 ;
10914   PLFLT *arg5 = (PLFLT *) 0 ;
10915   PLFLT *arg6 = (PLFLT *) 0 ;
10916   PLFLT *arg7 = (PLFLT *) 0 ;
10917   PLBOOL *arg8 = (PLBOOL *) 0 ;
10918   int val1 ;
10919   int ecode1 = 0 ;
10920   PyArrayObject *tmp2 = NULL ;
10921   PyArrayObject *tmp4 = NULL ;
10922   PyArrayObject *tmp5 = NULL ;
10923   PyArrayObject *tmp6 = NULL ;
10924   PyArrayObject *tmp7 = NULL ;
10925   PyArrayObject *tmp8 = NULL ;
10926   PyObject * obj0 = 0 ;
10927   PyObject * obj1 = 0 ;
10928   PyObject * obj2 = 0 ;
10929   PyObject * obj3 = 0 ;
10930   PyObject * obj4 = 0 ;
10931   PyObject * obj5 = 0 ;
10932   PyObject * obj6 = 0 ;
10933   
10934   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plscmap1la",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10935   ecode1 = SWIG_AsVal_int(obj0, &val1);
10936   if (!SWIG_IsOK(ecode1)) {
10937     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
10938   } 
10939   arg1 = (PLBOOL)(val1);
10940   {
10941     tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
10942     if ( tmp2 == NULL )
10943     return NULL;
10944     arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10945     arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10946   }
10947   {
10948     tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
10949     if ( tmp4 == NULL )
10950     return NULL;
10951     if ( PyArray_DIMS( tmp4 )[0] != Alen )
10952     {
10953       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10954       return NULL;
10955     }
10956     arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10957   }
10958   {
10959     tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( obj3, NPY_PLFLT, 1, 1 );
10960     if ( tmp5 == NULL )
10961     return NULL;
10962     if ( PyArray_DIMS( tmp5 )[0] != Alen )
10963     {
10964       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10965       return NULL;
10966     }
10967     arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10968   }
10969   {
10970     tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( obj4, NPY_PLFLT, 1, 1 );
10971     if ( tmp6 == NULL )
10972     return NULL;
10973     if ( PyArray_DIMS( tmp6 )[0] != Alen )
10974     {
10975       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10976       return NULL;
10977     }
10978     arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10979   }
10980   {
10981     tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
10982     if ( tmp7 == NULL )
10983     return NULL;
10984     if ( PyArray_DIMS( tmp7 )[0] != Alen )
10985     {
10986       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10987       return NULL;
10988     }
10989     arg7 = (PLFLT *) PyArray_DATA( tmp7 );
10990   }
10991   {
10992     tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj6, NPY_PLINT, 1, 1 );
10993     if ( tmp8 == NULL )
10994     return NULL;
10995     if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
10996     {
10997       PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10998       return NULL;
10999     }
11000     arg8 = (PLINT *) PyArray_DATA( tmp8 );
11001   }
11002   plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
11003   resultobj = SWIG_Py_Void();
11004   {
11005     Py_CLEAR( tmp2 );
11006   }
11007   {
11008     Py_CLEAR( tmp4 );
11009   }
11010   {
11011     Py_CLEAR( tmp5 );
11012   }
11013   {
11014     Py_CLEAR( tmp6 );
11015   }
11016   {
11017     Py_CLEAR( tmp7 );
11018   }
11019   {
11020     Py_CLEAR( tmp8 );
11021   }
11022   return resultobj;
11023 fail:
11024   {
11025     Py_CLEAR( tmp2 );
11026   }
11027   {
11028     Py_CLEAR( tmp4 );
11029   }
11030   {
11031     Py_CLEAR( tmp5 );
11032   }
11033   {
11034     Py_CLEAR( tmp6 );
11035   }
11036   {
11037     Py_CLEAR( tmp7 );
11038   }
11039   {
11040     Py_CLEAR( tmp8 );
11041   }
11042   return NULL;
11043 }
11044 
11045 
11046 SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11047   PyObject *resultobj = 0;
11048   PLINT arg1 ;
11049   int val1 ;
11050   int ecode1 = 0 ;
11051   PyObject * obj0 = 0 ;
11052   
11053   if (!PyArg_ParseTuple(args,(char *)"O:plscmap1n",&obj0)) SWIG_fail;
11054   ecode1 = SWIG_AsVal_int(obj0, &val1);
11055   if (!SWIG_IsOK(ecode1)) {
11056     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
11057   } 
11058   arg1 = (PLINT)(val1);
11059   plscmap1n(arg1);
11060   resultobj = SWIG_Py_Void();
11061   return resultobj;
11062 fail:
11063   return NULL;
11064 }
11065 
11066 
11067 SWIGINTERN PyObject *_wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11068   PyObject *resultobj = 0;
11069   PLFLT arg1 ;
11070   PLFLT arg2 ;
11071   double val1 ;
11072   int ecode1 = 0 ;
11073   double val2 ;
11074   int ecode2 = 0 ;
11075   PyObject * obj0 = 0 ;
11076   PyObject * obj1 = 0 ;
11077   
11078   if (!PyArg_ParseTuple(args,(char *)"OO:plscmap1_range",&obj0,&obj1)) SWIG_fail;
11079   ecode1 = SWIG_AsVal_double(obj0, &val1);
11080   if (!SWIG_IsOK(ecode1)) {
11081     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
11082   } 
11083   arg1 = (PLFLT)(val1);
11084   ecode2 = SWIG_AsVal_double(obj1, &val2);
11085   if (!SWIG_IsOK(ecode2)) {
11086     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
11087   } 
11088   arg2 = (PLFLT)(val2);
11089   plscmap1_range(arg1,arg2);
11090   resultobj = SWIG_Py_Void();
11091   return resultobj;
11092 fail:
11093   return NULL;
11094 }
11095 
11096 
11097 SWIGINTERN PyObject *_wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11098   PyObject *resultobj = 0;
11099   PLFLT *arg1 = (PLFLT *) 0 ;
11100   PLFLT *arg2 = (PLFLT *) 0 ;
11101   PLFLT temp1 ;
11102   int res1 = SWIG_TMPOBJ ;
11103   PLFLT temp2 ;
11104   int res2 = SWIG_TMPOBJ ;
11105   
11106   arg1 = &temp1;
11107   arg2 = &temp2;
11108   if (!PyArg_ParseTuple(args,(char *)":plgcmap1_range")) SWIG_fail;
11109   plgcmap1_range(arg1,arg2);
11110   resultobj = SWIG_Py_Void();
11111   if (SWIG_IsTmpObj(res1)) {
11112     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
11113   } else {
11114     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
11115     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11116   }
11117   if (SWIG_IsTmpObj(res2)) {
11118     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
11119   } else {
11120     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
11121     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11122   }
11123   return resultobj;
11124 fail:
11125   return NULL;
11126 }
11127 
11128 
11129 SWIGINTERN PyObject *_wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11130   PyObject *resultobj = 0;
11131   PLINT arg1 ;
11132   PLINT arg2 ;
11133   PLINT arg3 ;
11134   PLINT arg4 ;
11135   int val1 ;
11136   int ecode1 = 0 ;
11137   int val2 ;
11138   int ecode2 = 0 ;
11139   int val3 ;
11140   int ecode3 = 0 ;
11141   int val4 ;
11142   int ecode4 = 0 ;
11143   PyObject * obj0 = 0 ;
11144   PyObject * obj1 = 0 ;
11145   PyObject * obj2 = 0 ;
11146   PyObject * obj3 = 0 ;
11147   
11148   if (!PyArg_ParseTuple(args,(char *)"OOOO:plscol0",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11149   ecode1 = SWIG_AsVal_int(obj0, &val1);
11150   if (!SWIG_IsOK(ecode1)) {
11151     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
11152   } 
11153   arg1 = (PLINT)(val1);
11154   ecode2 = SWIG_AsVal_int(obj1, &val2);
11155   if (!SWIG_IsOK(ecode2)) {
11156     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
11157   } 
11158   arg2 = (PLINT)(val2);
11159   ecode3 = SWIG_AsVal_int(obj2, &val3);
11160   if (!SWIG_IsOK(ecode3)) {
11161     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
11162   } 
11163   arg3 = (PLINT)(val3);
11164   ecode4 = SWIG_AsVal_int(obj3, &val4);
11165   if (!SWIG_IsOK(ecode4)) {
11166     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
11167   } 
11168   arg4 = (PLINT)(val4);
11169   plscol0(arg1,arg2,arg3,arg4);
11170   resultobj = SWIG_Py_Void();
11171   return resultobj;
11172 fail:
11173   return NULL;
11174 }
11175 
11176 
11177 SWIGINTERN PyObject *_wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11178   PyObject *resultobj = 0;
11179   PLINT arg1 ;
11180   PLINT arg2 ;
11181   PLINT arg3 ;
11182   PLINT arg4 ;
11183   PLFLT arg5 ;
11184   int val1 ;
11185   int ecode1 = 0 ;
11186   int val2 ;
11187   int ecode2 = 0 ;
11188   int val3 ;
11189   int ecode3 = 0 ;
11190   int val4 ;
11191   int ecode4 = 0 ;
11192   double val5 ;
11193   int ecode5 = 0 ;
11194   PyObject * obj0 = 0 ;
11195   PyObject * obj1 = 0 ;
11196   PyObject * obj2 = 0 ;
11197   PyObject * obj3 = 0 ;
11198   PyObject * obj4 = 0 ;
11199   
11200   if (!PyArg_ParseTuple(args,(char *)"OOOOO:plscol0a",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11201   ecode1 = SWIG_AsVal_int(obj0, &val1);
11202   if (!SWIG_IsOK(ecode1)) {
11203     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
11204   } 
11205   arg1 = (PLINT)(val1);
11206   ecode2 = SWIG_AsVal_int(obj1, &val2);
11207   if (!SWIG_IsOK(ecode2)) {
11208     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
11209   } 
11210   arg2 = (PLINT)(val2);
11211   ecode3 = SWIG_AsVal_int(obj2, &val3);
11212   if (!SWIG_IsOK(ecode3)) {
11213     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
11214   } 
11215   arg3 = (PLINT)(val3);
11216   ecode4 = SWIG_AsVal_int(obj3, &val4);
11217   if (!SWIG_IsOK(ecode4)) {
11218     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
11219   } 
11220   arg4 = (PLINT)(val4);
11221   ecode5 = SWIG_AsVal_double(obj4, &val5);
11222   if (!SWIG_IsOK(ecode5)) {
11223     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
11224   } 
11225   arg5 = (PLFLT)(val5);
11226   plscol0a(arg1,arg2,arg3,arg4,arg5);
11227   resultobj = SWIG_Py_Void();
11228   return resultobj;
11229 fail:
11230   return NULL;
11231 }
11232 
11233 
11234 SWIGINTERN PyObject *_wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11235   PyObject *resultobj = 0;
11236   PLINT arg1 ;
11237   PLINT arg2 ;
11238   PLINT arg3 ;
11239   int val1 ;
11240   int ecode1 = 0 ;
11241   int val2 ;
11242   int ecode2 = 0 ;
11243   int val3 ;
11244   int ecode3 = 0 ;
11245   PyObject * obj0 = 0 ;
11246   PyObject * obj1 = 0 ;
11247   PyObject * obj2 = 0 ;
11248   
11249   if (!PyArg_ParseTuple(args,(char *)"OOO:plscolbg",&obj0,&obj1,&obj2)) SWIG_fail;
11250   ecode1 = SWIG_AsVal_int(obj0, &val1);
11251   if (!SWIG_IsOK(ecode1)) {
11252     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
11253   } 
11254   arg1 = (PLINT)(val1);
11255   ecode2 = SWIG_AsVal_int(obj1, &val2);
11256   if (!SWIG_IsOK(ecode2)) {
11257     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
11258   } 
11259   arg2 = (PLINT)(val2);
11260   ecode3 = SWIG_AsVal_int(obj2, &val3);
11261   if (!SWIG_IsOK(ecode3)) {
11262     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
11263   } 
11264   arg3 = (PLINT)(val3);
11265   plscolbg(arg1,arg2,arg3);
11266   resultobj = SWIG_Py_Void();
11267   return resultobj;
11268 fail:
11269   return NULL;
11270 }
11271 
11272 
11273 SWIGINTERN PyObject *_wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11274   PyObject *resultobj = 0;
11275   PLINT arg1 ;
11276   PLINT arg2 ;
11277   PLINT arg3 ;
11278   PLFLT arg4 ;
11279   int val1 ;
11280   int ecode1 = 0 ;
11281   int val2 ;
11282   int ecode2 = 0 ;
11283   int val3 ;
11284   int ecode3 = 0 ;
11285   double val4 ;
11286   int ecode4 = 0 ;
11287   PyObject * obj0 = 0 ;
11288   PyObject * obj1 = 0 ;
11289   PyObject * obj2 = 0 ;
11290   PyObject * obj3 = 0 ;
11291   
11292   if (!PyArg_ParseTuple(args,(char *)"OOOO:plscolbga",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11293   ecode1 = SWIG_AsVal_int(obj0, &val1);
11294   if (!SWIG_IsOK(ecode1)) {
11295     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
11296   } 
11297   arg1 = (PLINT)(val1);
11298   ecode2 = SWIG_AsVal_int(obj1, &val2);
11299   if (!SWIG_IsOK(ecode2)) {
11300     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
11301   } 
11302   arg2 = (PLINT)(val2);
11303   ecode3 = SWIG_AsVal_int(obj2, &val3);
11304   if (!SWIG_IsOK(ecode3)) {
11305     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
11306   } 
11307   arg3 = (PLINT)(val3);
11308   ecode4 = SWIG_AsVal_double(obj3, &val4);
11309   if (!SWIG_IsOK(ecode4)) {
11310     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
11311   } 
11312   arg4 = (PLFLT)(val4);
11313   plscolbga(arg1,arg2,arg3,arg4);
11314   resultobj = SWIG_Py_Void();
11315   return resultobj;
11316 fail:
11317   return NULL;
11318 }
11319 
11320 
11321 SWIGINTERN PyObject *_wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11322   PyObject *resultobj = 0;
11323   PLINT arg1 ;
11324   int val1 ;
11325   int ecode1 = 0 ;
11326   PyObject * obj0 = 0 ;
11327   
11328   if (!PyArg_ParseTuple(args,(char *)"O:plscolor",&obj0)) SWIG_fail;
11329   ecode1 = SWIG_AsVal_int(obj0, &val1);
11330   if (!SWIG_IsOK(ecode1)) {
11331     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
11332   } 
11333   arg1 = (PLINT)(val1);
11334   plscolor(arg1);
11335   resultobj = SWIG_Py_Void();
11336   return resultobj;
11337 fail:
11338   return NULL;
11339 }
11340 
11341 
11342 SWIGINTERN PyObject *_wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11343   PyObject *resultobj = 0;
11344   PLINT arg1 ;
11345   int val1 ;
11346   int ecode1 = 0 ;
11347   PyObject * obj0 = 0 ;
11348   
11349   if (!PyArg_ParseTuple(args,(char *)"O:plscompression",&obj0)) SWIG_fail;
11350   ecode1 = SWIG_AsVal_int(obj0, &val1);
11351   if (!SWIG_IsOK(ecode1)) {
11352     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
11353   } 
11354   arg1 = (PLINT)(val1);
11355   plscompression(arg1);
11356   resultobj = SWIG_Py_Void();
11357   return resultobj;
11358 fail:
11359   return NULL;
11360 }
11361 
11362 
11363 SWIGINTERN PyObject *_wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11364   PyObject *resultobj = 0;
11365   char *arg1 = (char *) 0 ;
11366   int res1 ;
11367   char *buf1 = 0 ;
11368   int alloc1 = 0 ;
11369   PyObject * obj0 = 0 ;
11370   
11371   if (!PyArg_ParseTuple(args,(char *)"O:plsdev",&obj0)) SWIG_fail;
11372   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11373   if (!SWIG_IsOK(res1)) {
11374     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
11375   }
11376   arg1 = (char *)(buf1);
11377   plsdev((char const *)arg1);
11378   resultobj = SWIG_Py_Void();
11379   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11380   return resultobj;
11381 fail:
11382   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11383   return NULL;
11384 }
11385 
11386 
11387 SWIGINTERN PyObject *_wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11388   PyObject *resultobj = 0;
11389   PLFLT arg1 ;
11390   PLFLT arg2 ;
11391   PLFLT arg3 ;
11392   PLFLT arg4 ;
11393   double val1 ;
11394   int ecode1 = 0 ;
11395   double val2 ;
11396   int ecode2 = 0 ;
11397   double val3 ;
11398   int ecode3 = 0 ;
11399   double val4 ;
11400   int ecode4 = 0 ;
11401   PyObject * obj0 = 0 ;
11402   PyObject * obj1 = 0 ;
11403   PyObject * obj2 = 0 ;
11404   PyObject * obj3 = 0 ;
11405   
11406   if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdidev",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11407   ecode1 = SWIG_AsVal_double(obj0, &val1);
11408   if (!SWIG_IsOK(ecode1)) {
11409     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
11410   } 
11411   arg1 = (PLFLT)(val1);
11412   ecode2 = SWIG_AsVal_double(obj1, &val2);
11413   if (!SWIG_IsOK(ecode2)) {
11414     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
11415   } 
11416   arg2 = (PLFLT)(val2);
11417   ecode3 = SWIG_AsVal_double(obj2, &val3);
11418   if (!SWIG_IsOK(ecode3)) {
11419     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
11420   } 
11421   arg3 = (PLFLT)(val3);
11422   ecode4 = SWIG_AsVal_double(obj3, &val4);
11423   if (!SWIG_IsOK(ecode4)) {
11424     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
11425   } 
11426   arg4 = (PLFLT)(val4);
11427   plsdidev(arg1,arg2,arg3,arg4);
11428   resultobj = SWIG_Py_Void();
11429   return resultobj;
11430 fail:
11431   return NULL;
11432 }
11433 
11434 
11435 SWIGINTERN PyObject *_wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11436   PyObject *resultobj = 0;
11437   PLINT arg1 ;
11438   PLINT arg2 ;
11439   PLINT arg3 ;
11440   PLINT arg4 ;
11441   PLFLT arg5 ;
11442   PLFLT arg6 ;
11443   int val1 ;
11444   int ecode1 = 0 ;
11445   int val2 ;
11446   int ecode2 = 0 ;
11447   int val3 ;
11448   int ecode3 = 0 ;
11449   int val4 ;
11450   int ecode4 = 0 ;
11451   double val5 ;
11452   int ecode5 = 0 ;
11453   double val6 ;
11454   int ecode6 = 0 ;
11455   PyObject * obj0 = 0 ;
11456   PyObject * obj1 = 0 ;
11457   PyObject * obj2 = 0 ;
11458   PyObject * obj3 = 0 ;
11459   PyObject * obj4 = 0 ;
11460   PyObject * obj5 = 0 ;
11461   
11462   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plsdimap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
11463   ecode1 = SWIG_AsVal_int(obj0, &val1);
11464   if (!SWIG_IsOK(ecode1)) {
11465     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
11466   } 
11467   arg1 = (PLINT)(val1);
11468   ecode2 = SWIG_AsVal_int(obj1, &val2);
11469   if (!SWIG_IsOK(ecode2)) {
11470     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
11471   } 
11472   arg2 = (PLINT)(val2);
11473   ecode3 = SWIG_AsVal_int(obj2, &val3);
11474   if (!SWIG_IsOK(ecode3)) {
11475     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
11476   } 
11477   arg3 = (PLINT)(val3);
11478   ecode4 = SWIG_AsVal_int(obj3, &val4);
11479   if (!SWIG_IsOK(ecode4)) {
11480     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
11481   } 
11482   arg4 = (PLINT)(val4);
11483   ecode5 = SWIG_AsVal_double(obj4, &val5);
11484   if (!SWIG_IsOK(ecode5)) {
11485     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
11486   } 
11487   arg5 = (PLFLT)(val5);
11488   ecode6 = SWIG_AsVal_double(obj5, &val6);
11489   if (!SWIG_IsOK(ecode6)) {
11490     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
11491   } 
11492   arg6 = (PLFLT)(val6);
11493   plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11494   resultobj = SWIG_Py_Void();
11495   return resultobj;
11496 fail:
11497   return NULL;
11498 }
11499 
11500 
11501 SWIGINTERN PyObject *_wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11502   PyObject *resultobj = 0;
11503   PLFLT arg1 ;
11504   double val1 ;
11505   int ecode1 = 0 ;
11506   PyObject * obj0 = 0 ;
11507   
11508   if (!PyArg_ParseTuple(args,(char *)"O:plsdiori",&obj0)) SWIG_fail;
11509   ecode1 = SWIG_AsVal_double(obj0, &val1);
11510   if (!SWIG_IsOK(ecode1)) {
11511     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
11512   } 
11513   arg1 = (PLFLT)(val1);
11514   plsdiori(arg1);
11515   resultobj = SWIG_Py_Void();
11516   return resultobj;
11517 fail:
11518   return NULL;
11519 }
11520 
11521 
11522 SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11523   PyObject *resultobj = 0;
11524   PLFLT arg1 ;
11525   PLFLT arg2 ;
11526   PLFLT arg3 ;
11527   PLFLT arg4 ;
11528   double val1 ;
11529   int ecode1 = 0 ;
11530   double val2 ;
11531   int ecode2 = 0 ;
11532   double val3 ;
11533   int ecode3 = 0 ;
11534   double val4 ;
11535   int ecode4 = 0 ;
11536   PyObject * obj0 = 0 ;
11537   PyObject * obj1 = 0 ;
11538   PyObject * obj2 = 0 ;
11539   PyObject * obj3 = 0 ;
11540   
11541   if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplt",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11542   ecode1 = SWIG_AsVal_double(obj0, &val1);
11543   if (!SWIG_IsOK(ecode1)) {
11544     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
11545   } 
11546   arg1 = (PLFLT)(val1);
11547   ecode2 = SWIG_AsVal_double(obj1, &val2);
11548   if (!SWIG_IsOK(ecode2)) {
11549     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
11550   } 
11551   arg2 = (PLFLT)(val2);
11552   ecode3 = SWIG_AsVal_double(obj2, &val3);
11553   if (!SWIG_IsOK(ecode3)) {
11554     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
11555   } 
11556   arg3 = (PLFLT)(val3);
11557   ecode4 = SWIG_AsVal_double(obj3, &val4);
11558   if (!SWIG_IsOK(ecode4)) {
11559     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
11560   } 
11561   arg4 = (PLFLT)(val4);
11562   plsdiplt(arg1,arg2,arg3,arg4);
11563   resultobj = SWIG_Py_Void();
11564   return resultobj;
11565 fail:
11566   return NULL;
11567 }
11568 
11569 
11570 SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11571   PyObject *resultobj = 0;
11572   PLFLT arg1 ;
11573   PLFLT arg2 ;
11574   PLFLT arg3 ;
11575   PLFLT arg4 ;
11576   double val1 ;
11577   int ecode1 = 0 ;
11578   double val2 ;
11579   int ecode2 = 0 ;
11580   double val3 ;
11581   int ecode3 = 0 ;
11582   double val4 ;
11583   int ecode4 = 0 ;
11584   PyObject * obj0 = 0 ;
11585   PyObject * obj1 = 0 ;
11586   PyObject * obj2 = 0 ;
11587   PyObject * obj3 = 0 ;
11588   
11589   if (!PyArg_ParseTuple(args,(char *)"OOOO:plsdiplz",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11590   ecode1 = SWIG_AsVal_double(obj0, &val1);
11591   if (!SWIG_IsOK(ecode1)) {
11592     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
11593   } 
11594   arg1 = (PLFLT)(val1);
11595   ecode2 = SWIG_AsVal_double(obj1, &val2);
11596   if (!SWIG_IsOK(ecode2)) {
11597     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
11598   } 
11599   arg2 = (PLFLT)(val2);
11600   ecode3 = SWIG_AsVal_double(obj2, &val3);
11601   if (!SWIG_IsOK(ecode3)) {
11602     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
11603   } 
11604   arg3 = (PLFLT)(val3);
11605   ecode4 = SWIG_AsVal_double(obj3, &val4);
11606   if (!SWIG_IsOK(ecode4)) {
11607     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
11608   } 
11609   arg4 = (PLFLT)(val4);
11610   plsdiplz(arg1,arg2,arg3,arg4);
11611   resultobj = SWIG_Py_Void();
11612   return resultobj;
11613 fail:
11614   return NULL;
11615 }
11616 
11617 
11618 SWIGINTERN PyObject *_wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11619   PyObject *resultobj = 0;
11620   unsigned int arg1 ;
11621   unsigned int val1 ;
11622   int ecode1 = 0 ;
11623   PyObject * obj0 = 0 ;
11624   
11625   if (!PyArg_ParseTuple(args,(char *)"O:plseed",&obj0)) SWIG_fail;
11626   ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
11627   if (!SWIG_IsOK(ecode1)) {
11628     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
11629   } 
11630   arg1 = (unsigned int)(val1);
11631   plseed(arg1);
11632   resultobj = SWIG_Py_Void();
11633   return resultobj;
11634 fail:
11635   return NULL;
11636 }
11637 
11638 
11639 SWIGINTERN PyObject *_wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11640   PyObject *resultobj = 0;
11641   char arg1 ;
11642   char val1 ;
11643   int ecode1 = 0 ;
11644   PyObject * obj0 = 0 ;
11645   
11646   if (!PyArg_ParseTuple(args,(char *)"O:plsesc",&obj0)) SWIG_fail;
11647   ecode1 = SWIG_AsVal_char(obj0, &val1);
11648   if (!SWIG_IsOK(ecode1)) {
11649     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
11650   } 
11651   arg1 = (char)(val1);
11652   plsesc(arg1);
11653   resultobj = SWIG_Py_Void();
11654   return resultobj;
11655 fail:
11656   return NULL;
11657 }
11658 
11659 
11660 SWIGINTERN PyObject *_wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11661   PyObject *resultobj = 0;
11662   char *arg1 = (char *) 0 ;
11663   char *arg2 = (char *) 0 ;
11664   int res1 ;
11665   char *buf1 = 0 ;
11666   int alloc1 = 0 ;
11667   int res2 ;
11668   char *buf2 = 0 ;
11669   int alloc2 = 0 ;
11670   PyObject * obj0 = 0 ;
11671   PyObject * obj1 = 0 ;
11672   PLINT result;
11673   
11674   if (!PyArg_ParseTuple(args,(char *)"OO:plsetopt",&obj0,&obj1)) SWIG_fail;
11675   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11676   if (!SWIG_IsOK(res1)) {
11677     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'");
11678   }
11679   arg1 = (char *)(buf1);
11680   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
11681   if (!SWIG_IsOK(res2)) {
11682     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'");
11683   }
11684   arg2 = (char *)(buf2);
11685   result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
11686   resultobj = SWIG_From_int((int)(result));
11687   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11688   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11689   return resultobj;
11690 fail:
11691   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11692   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11693   return NULL;
11694 }
11695 
11696 
11697 SWIGINTERN PyObject *_wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11698   PyObject *resultobj = 0;
11699   PLINT arg1 ;
11700   PLINT arg2 ;
11701   PLINT arg3 ;
11702   int val1 ;
11703   int ecode1 = 0 ;
11704   int val2 ;
11705   int ecode2 = 0 ;
11706   int val3 ;
11707   int ecode3 = 0 ;
11708   PyObject * obj0 = 0 ;
11709   PyObject * obj1 = 0 ;
11710   PyObject * obj2 = 0 ;
11711   
11712   if (!PyArg_ParseTuple(args,(char *)"OOO:plsfam",&obj0,&obj1,&obj2)) SWIG_fail;
11713   ecode1 = SWIG_AsVal_int(obj0, &val1);
11714   if (!SWIG_IsOK(ecode1)) {
11715     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
11716   } 
11717   arg1 = (PLINT)(val1);
11718   ecode2 = SWIG_AsVal_int(obj1, &val2);
11719   if (!SWIG_IsOK(ecode2)) {
11720     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
11721   } 
11722   arg2 = (PLINT)(val2);
11723   ecode3 = SWIG_AsVal_int(obj2, &val3);
11724   if (!SWIG_IsOK(ecode3)) {
11725     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
11726   } 
11727   arg3 = (PLINT)(val3);
11728   plsfam(arg1,arg2,arg3);
11729   resultobj = SWIG_Py_Void();
11730   return resultobj;
11731 fail:
11732   return NULL;
11733 }
11734 
11735 
11736 SWIGINTERN PyObject *_wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11737   PyObject *resultobj = 0;
11738   PLUNICODE arg1 ;
11739   unsigned int val1 ;
11740   int ecode1 = 0 ;
11741   PyObject * obj0 = 0 ;
11742   
11743   if (!PyArg_ParseTuple(args,(char *)"O:plsfci",&obj0)) SWIG_fail;
11744   ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
11745   if (!SWIG_IsOK(ecode1)) {
11746     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
11747   } 
11748   arg1 = (PLUNICODE)(val1);
11749   plsfci(arg1);
11750   resultobj = SWIG_Py_Void();
11751   return resultobj;
11752 fail:
11753   return NULL;
11754 }
11755 
11756 
11757 SWIGINTERN PyObject *_wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11758   PyObject *resultobj = 0;
11759   char *arg1 = (char *) 0 ;
11760   int res1 ;
11761   char *buf1 = 0 ;
11762   int alloc1 = 0 ;
11763   PyObject * obj0 = 0 ;
11764   
11765   if (!PyArg_ParseTuple(args,(char *)"O:plsfnam",&obj0)) SWIG_fail;
11766   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
11767   if (!SWIG_IsOK(res1)) {
11768     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
11769   }
11770   arg1 = (char *)(buf1);
11771   plsfnam((char const *)arg1);
11772   resultobj = SWIG_Py_Void();
11773   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11774   return resultobj;
11775 fail:
11776   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11777   return NULL;
11778 }
11779 
11780 
11781 SWIGINTERN PyObject *_wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11782   PyObject *resultobj = 0;
11783   PLINT arg1 ;
11784   PLINT arg2 ;
11785   PLINT arg3 ;
11786   int val1 ;
11787   int ecode1 = 0 ;
11788   int val2 ;
11789   int ecode2 = 0 ;
11790   int val3 ;
11791   int ecode3 = 0 ;
11792   PyObject * obj0 = 0 ;
11793   PyObject * obj1 = 0 ;
11794   PyObject * obj2 = 0 ;
11795   
11796   if (!PyArg_ParseTuple(args,(char *)"OOO:plsfont",&obj0,&obj1,&obj2)) SWIG_fail;
11797   ecode1 = SWIG_AsVal_int(obj0, &val1);
11798   if (!SWIG_IsOK(ecode1)) {
11799     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
11800   } 
11801   arg1 = (PLINT)(val1);
11802   ecode2 = SWIG_AsVal_int(obj1, &val2);
11803   if (!SWIG_IsOK(ecode2)) {
11804     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
11805   } 
11806   arg2 = (PLINT)(val2);
11807   ecode3 = SWIG_AsVal_int(obj2, &val3);
11808   if (!SWIG_IsOK(ecode3)) {
11809     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
11810   } 
11811   arg3 = (PLINT)(val3);
11812   plsfont(arg1,arg2,arg3);
11813   resultobj = SWIG_Py_Void();
11814   return resultobj;
11815 fail:
11816   return NULL;
11817 }
11818 
11819 
11820 SWIGINTERN PyObject *_wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11821   PyObject *resultobj = 0;
11822   PLFLT **arg1 = (PLFLT **) 0 ;
11823   PLINT arg2 ;
11824   PLINT arg3 ;
11825   defined_func arg4 = (defined_func) 0 ;
11826   PLFLT arg5 ;
11827   PLFLT arg6 ;
11828   PLFLT arg7 ;
11829   PLFLT arg8 ;
11830   PLFLT *arg9 = (PLFLT *) 0 ;
11831   PLINT arg10 ;
11832   PLFLT arg11 ;
11833   PLINT arg12 ;
11834   PLFLT arg13 ;
11835   fill_func arg14 = (fill_func) 0 ;
11836   PLBOOL arg15 ;
11837   pltr_func arg16 = (pltr_func) 0 ;
11838   PLPointer arg17 = (PLPointer) 0 ;
11839   PyArrayObject *tmp1 = NULL ;
11840   double val5 ;
11841   int ecode5 = 0 ;
11842   double val6 ;
11843   int ecode6 = 0 ;
11844   double val7 ;
11845   int ecode7 = 0 ;
11846   double val8 ;
11847   int ecode8 = 0 ;
11848   PyArrayObject *tmp9 = NULL ;
11849   double val11 ;
11850   int ecode11 = 0 ;
11851   int val12 ;
11852   int ecode12 = 0 ;
11853   double val13 ;
11854   int ecode13 = 0 ;
11855   int val15 ;
11856   int ecode15 = 0 ;
11857   PyObject * obj0 = 0 ;
11858   PyObject * obj1 = 0 ;
11859   PyObject * obj2 = 0 ;
11860   PyObject * obj3 = 0 ;
11861   PyObject * obj4 = 0 ;
11862   PyObject * obj5 = 0 ;
11863   PyObject * obj6 = 0 ;
11864   PyObject * obj7 = 0 ;
11865   PyObject * obj8 = 0 ;
11866   PyObject * obj9 = 0 ;
11867   PyObject * obj10 = 0 ;
11868   PyObject * obj11 = 0 ;
11869   
11870   {
11871     python_pltr = 0;
11872     arg16          = NULL;
11873   }
11874   {
11875     arg17 = NULL;
11876   }
11877   {
11878     arg4 = NULL;
11879   }
11880   {
11881     arg14 = plfill;
11882   }
11883   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO|OO:plshades",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
11884   {
11885     int i, size;
11886     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
11887     if ( tmp1 == NULL )
11888     return NULL;
11889     Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11890     Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11891     size = arg3;
11892     arg1   = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
11893     for ( i = 0; i < arg2; i++ )
11894     arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
11895   }
11896   ecode5 = SWIG_AsVal_double(obj1, &val5);
11897   if (!SWIG_IsOK(ecode5)) {
11898     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
11899   } 
11900   arg5 = (PLFLT)(val5);
11901   ecode6 = SWIG_AsVal_double(obj2, &val6);
11902   if (!SWIG_IsOK(ecode6)) {
11903     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
11904   } 
11905   arg6 = (PLFLT)(val6);
11906   ecode7 = SWIG_AsVal_double(obj3, &val7);
11907   if (!SWIG_IsOK(ecode7)) {
11908     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
11909   } 
11910   arg7 = (PLFLT)(val7);
11911   ecode8 = SWIG_AsVal_double(obj4, &val8);
11912   if (!SWIG_IsOK(ecode8)) {
11913     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'");
11914   } 
11915   arg8 = (PLFLT)(val8);
11916   {
11917     tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( obj5, NPY_PLFLT, 1, 1 );
11918     if ( tmp9 == NULL )
11919     return NULL;
11920     arg10 = PyArray_DIMS( tmp9 )[0];
11921     arg9 = (PLFLT *) PyArray_DATA( tmp9 );
11922   }
11923   ecode11 = SWIG_AsVal_double(obj6, &val11);
11924   if (!SWIG_IsOK(ecode11)) {
11925     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLFLT""'");
11926   } 
11927   arg11 = (PLFLT)(val11);
11928   ecode12 = SWIG_AsVal_int(obj7, &val12);
11929   if (!SWIG_IsOK(ecode12)) {
11930     SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
11931   } 
11932   arg12 = (PLINT)(val12);
11933   ecode13 = SWIG_AsVal_double(obj8, &val13);
11934   if (!SWIG_IsOK(ecode13)) {
11935     SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLFLT""'");
11936   } 
11937   arg13 = (PLFLT)(val13);
11938   ecode15 = SWIG_AsVal_int(obj9, &val15);
11939   if (!SWIG_IsOK(ecode15)) {
11940     SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'");
11941   } 
11942   arg15 = (PLBOOL)(val15);
11943   if (obj10) {
11944     {
11945       // it must be a callable or None
11946       if ( obj10 == Py_None )
11947       {
11948         arg16 = NULL;
11949       }
11950       else
11951       {
11952         if ( !PyCallable_Check( (PyObject *) obj10 ) )
11953         {
11954           PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
11955           return NULL;
11956         }
11957         arg16 = marshal_pltr( obj10 );
11958       }
11959     }
11960   }
11961   if (obj11) {
11962     {
11963       if ( obj11 == Py_None )
11964       arg17 = NULL;
11965       else
11966       {
11967         arg17 = marshal_PLPointer( obj11, 0 );
11968       }
11969     }
11970   }
11971   plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
11972   resultobj = SWIG_Py_Void();
11973   {
11974     Py_CLEAR( tmp1 );
11975     free( arg1 );
11976   }
11977   {
11978     Py_CLEAR( tmp9 );
11979   }
11980   {
11981     cleanup_pltr();
11982   }
11983   {
11984     cleanup_PLPointer();
11985   }
11986   return resultobj;
11987 fail:
11988   {
11989     Py_CLEAR( tmp1 );
11990     free( arg1 );
11991   }
11992   {
11993     Py_CLEAR( tmp9 );
11994   }
11995   {
11996     cleanup_pltr();
11997   }
11998   {
11999     cleanup_PLPointer();
12000   }
12001   return NULL;
12002 }
12003 
12004 
12005 SWIGINTERN PyObject *_wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12006   PyObject *resultobj = 0;
12007   PLFLT **arg1 = (PLFLT **) 0 ;
12008   PLINT arg2 ;
12009   PLINT arg3 ;
12010   defined_func arg4 = (defined_func) 0 ;
12011   PLFLT arg5 ;
12012   PLFLT arg6 ;
12013   PLFLT arg7 ;
12014   PLFLT arg8 ;
12015   PLFLT arg9 ;
12016   PLFLT arg10 ;
12017   PLINT arg11 ;
12018   PLFLT arg12 ;
12019   PLFLT arg13 ;
12020   PLINT arg14 ;
12021   PLFLT arg15 ;
12022   PLINT arg16 ;
12023   PLFLT arg17 ;
12024   fill_func arg18 = (fill_func) 0 ;
12025   PLBOOL arg19 ;
12026   pltr_func arg20 = (pltr_func) 0 ;
12027   PLPointer arg21 = (PLPointer) 0 ;
12028   PyArrayObject *tmp1 = NULL ;
12029   double val5 ;
12030   int ecode5 = 0 ;
12031   double val6 ;
12032   int ecode6 = 0 ;
12033   double val7 ;
12034   int ecode7 = 0 ;
12035   double val8 ;
12036   int ecode8 = 0 ;
12037   double val9 ;
12038   int ecode9 = 0 ;
12039   double val10 ;
12040   int ecode10 = 0 ;
12041   int val11 ;
12042   int ecode11 = 0 ;
12043   double val12 ;
12044   int ecode12 = 0 ;
12045   double val13 ;
12046   int ecode13 = 0 ;
12047   int val14 ;
12048   int ecode14 = 0 ;
12049   double val15 ;
12050   int ecode15 = 0 ;
12051   int val16 ;
12052   int ecode16 = 0 ;
12053   double val17 ;
12054   int ecode17 = 0 ;
12055   int val19 ;
12056   int ecode19 = 0 ;
12057   PyObject * obj0 = 0 ;
12058   PyObject * obj1 = 0 ;
12059   PyObject * obj2 = 0 ;
12060   PyObject * obj3 = 0 ;
12061   PyObject * obj4 = 0 ;
12062   PyObject * obj5 = 0 ;
12063   PyObject * obj6 = 0 ;
12064   PyObject * obj7 = 0 ;
12065   PyObject * obj8 = 0 ;
12066   PyObject * obj9 = 0 ;
12067   PyObject * obj10 = 0 ;
12068   PyObject * obj11 = 0 ;
12069   PyObject * obj12 = 0 ;
12070   PyObject * obj13 = 0 ;
12071   PyObject * obj14 = 0 ;
12072   PyObject * obj15 = 0 ;
12073   PyObject * obj16 = 0 ;
12074   
12075   {
12076     python_pltr = 0;
12077     arg20          = NULL;
12078   }
12079   {
12080     arg21 = NULL;
12081   }
12082   {
12083     arg4 = NULL;
12084   }
12085   {
12086     arg18 = plfill;
12087   }
12088   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO|OO:plshade",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
12089   {
12090     int i, size;
12091     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
12092     if ( tmp1 == NULL )
12093     return NULL;
12094     Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12095     Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12096     size = arg3;
12097     arg1   = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12098     for ( i = 0; i < arg2; i++ )
12099     arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12100   }
12101   ecode5 = SWIG_AsVal_double(obj1, &val5);
12102   if (!SWIG_IsOK(ecode5)) {
12103     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
12104   } 
12105   arg5 = (PLFLT)(val5);
12106   ecode6 = SWIG_AsVal_double(obj2, &val6);
12107   if (!SWIG_IsOK(ecode6)) {
12108     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
12109   } 
12110   arg6 = (PLFLT)(val6);
12111   ecode7 = SWIG_AsVal_double(obj3, &val7);
12112   if (!SWIG_IsOK(ecode7)) {
12113     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
12114   } 
12115   arg7 = (PLFLT)(val7);
12116   ecode8 = SWIG_AsVal_double(obj4, &val8);
12117   if (!SWIG_IsOK(ecode8)) {
12118     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
12119   } 
12120   arg8 = (PLFLT)(val8);
12121   ecode9 = SWIG_AsVal_double(obj5, &val9);
12122   if (!SWIG_IsOK(ecode9)) {
12123     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
12124   } 
12125   arg9 = (PLFLT)(val9);
12126   ecode10 = SWIG_AsVal_double(obj6, &val10);
12127   if (!SWIG_IsOK(ecode10)) {
12128     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
12129   } 
12130   arg10 = (PLFLT)(val10);
12131   ecode11 = SWIG_AsVal_int(obj7, &val11);
12132   if (!SWIG_IsOK(ecode11)) {
12133     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
12134   } 
12135   arg11 = (PLINT)(val11);
12136   ecode12 = SWIG_AsVal_double(obj8, &val12);
12137   if (!SWIG_IsOK(ecode12)) {
12138     SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
12139   } 
12140   arg12 = (PLFLT)(val12);
12141   ecode13 = SWIG_AsVal_double(obj9, &val13);
12142   if (!SWIG_IsOK(ecode13)) {
12143     SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLFLT""'");
12144   } 
12145   arg13 = (PLFLT)(val13);
12146   ecode14 = SWIG_AsVal_int(obj10, &val14);
12147   if (!SWIG_IsOK(ecode14)) {
12148     SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
12149   } 
12150   arg14 = (PLINT)(val14);
12151   ecode15 = SWIG_AsVal_double(obj11, &val15);
12152   if (!SWIG_IsOK(ecode15)) {
12153     SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLFLT""'");
12154   } 
12155   arg15 = (PLFLT)(val15);
12156   ecode16 = SWIG_AsVal_int(obj12, &val16);
12157   if (!SWIG_IsOK(ecode16)) {
12158     SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
12159   } 
12160   arg16 = (PLINT)(val16);
12161   ecode17 = SWIG_AsVal_double(obj13, &val17);
12162   if (!SWIG_IsOK(ecode17)) {
12163     SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLFLT""'");
12164   } 
12165   arg17 = (PLFLT)(val17);
12166   ecode19 = SWIG_AsVal_int(obj14, &val19);
12167   if (!SWIG_IsOK(ecode19)) {
12168     SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'");
12169   } 
12170   arg19 = (PLBOOL)(val19);
12171   if (obj15) {
12172     {
12173       // it must be a callable or None
12174       if ( obj15 == Py_None )
12175       {
12176         arg20 = NULL;
12177       }
12178       else
12179       {
12180         if ( !PyCallable_Check( (PyObject *) obj15 ) )
12181         {
12182           PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12183           return NULL;
12184         }
12185         arg20 = marshal_pltr( obj15 );
12186       }
12187     }
12188   }
12189   if (obj16) {
12190     {
12191       if ( obj16 == Py_None )
12192       arg21 = NULL;
12193       else
12194       {
12195         arg21 = marshal_PLPointer( obj16, 0 );
12196       }
12197     }
12198   }
12199   plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
12200   resultobj = SWIG_Py_Void();
12201   {
12202     Py_CLEAR( tmp1 );
12203     free( arg1 );
12204   }
12205   {
12206     cleanup_pltr();
12207   }
12208   {
12209     cleanup_PLPointer();
12210   }
12211   return resultobj;
12212 fail:
12213   {
12214     Py_CLEAR( tmp1 );
12215     free( arg1 );
12216   }
12217   {
12218     cleanup_pltr();
12219   }
12220   {
12221     cleanup_PLPointer();
12222   }
12223   return NULL;
12224 }
12225 
12226 
12227 SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12228   PyObject *resultobj = 0;
12229   label_func arg1 = (label_func) 0 ;
12230   PLPointer arg2 = (PLPointer) 0 ;
12231   int res2 ;
12232   PyObject * obj0 = 0 ;
12233   PyObject * obj1 = 0 ;
12234   
12235   if (!PyArg_ParseTuple(args,(char *)"OO:plslabelfunc",&obj0,&obj1)) SWIG_fail;
12236   {
12237     // Release reference to previous function if applicable
12238     if ( python_label )
12239     {
12240       Py_CLEAR( python_label );
12241       python_label = 0;
12242     }
12243     // it must be a callable or None
12244     if ( obj0 == Py_None )
12245     {
12246       arg1 = NULL;
12247     }
12248     else
12249     {
12250       if ( !PyCallable_Check( (PyObject *) obj0 ) )
12251       {
12252         PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" );
12253         return NULL;
12254       }
12255       // hold a reference to it
12256       Py_XINCREF( (PyObject *) obj0 );
12257       python_label = (PyObject *) obj0;
12258       // this function handles calling the python function
12259       arg1 = do_label_callback;
12260     }
12261   }
12262   res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
12263   if (!SWIG_IsOK(res2)) {
12264     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'"); 
12265   }
12266   plslabelfunc(arg1,arg2);
12267   resultobj = SWIG_Py_Void();
12268   return resultobj;
12269 fail:
12270   return NULL;
12271 }
12272 
12273 
12274 SWIGINTERN PyObject *_wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12275   PyObject *resultobj = 0;
12276   PLFLT arg1 ;
12277   PLFLT arg2 ;
12278   double val1 ;
12279   int ecode1 = 0 ;
12280   double val2 ;
12281   int ecode2 = 0 ;
12282   PyObject * obj0 = 0 ;
12283   PyObject * obj1 = 0 ;
12284   
12285   if (!PyArg_ParseTuple(args,(char *)"OO:plsmaj",&obj0,&obj1)) SWIG_fail;
12286   ecode1 = SWIG_AsVal_double(obj0, &val1);
12287   if (!SWIG_IsOK(ecode1)) {
12288     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
12289   } 
12290   arg1 = (PLFLT)(val1);
12291   ecode2 = SWIG_AsVal_double(obj1, &val2);
12292   if (!SWIG_IsOK(ecode2)) {
12293     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
12294   } 
12295   arg2 = (PLFLT)(val2);
12296   plsmaj(arg1,arg2);
12297   resultobj = SWIG_Py_Void();
12298   return resultobj;
12299 fail:
12300   return NULL;
12301 }
12302 
12303 
12304 SWIGINTERN PyObject *_wrap_plsmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12305   PyObject *resultobj = 0;
12306   PLINT arg1 ;
12307   PLINT arg2 ;
12308   void *arg3 = (void *) 0 ;
12309   int val1 ;
12310   int ecode1 = 0 ;
12311   int val2 ;
12312   int ecode2 = 0 ;
12313   int res3 ;
12314   Py_ssize_t size3 = 0 ;
12315   void *buf3 = 0 ;
12316   PyObject * obj0 = 0 ;
12317   PyObject * obj1 = 0 ;
12318   PyObject * obj2 = 0 ;
12319   
12320   if (!PyArg_ParseTuple(args,(char *)"OOO:plsmem",&obj0,&obj1,&obj2)) SWIG_fail;
12321   ecode1 = SWIG_AsVal_int(obj0, &val1);
12322   if (!SWIG_IsOK(ecode1)) {
12323     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'");
12324   } 
12325   arg1 = (PLINT)(val1);
12326   ecode2 = SWIG_AsVal_int(obj1, &val2);
12327   if (!SWIG_IsOK(ecode2)) {
12328     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'");
12329   } 
12330   arg2 = (PLINT)(val2);
12331   {
12332     res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12333     if (res3<0) {
12334       PyErr_Clear();
12335       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'");
12336     }
12337     arg3 = (void *) buf3;
12338   }
12339   plsmem(arg1,arg2,arg3);
12340   resultobj = SWIG_Py_Void();
12341   return resultobj;
12342 fail:
12343   return NULL;
12344 }
12345 
12346 
12347 SWIGINTERN PyObject *_wrap_plsmema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12348   PyObject *resultobj = 0;
12349   PLINT arg1 ;
12350   PLINT arg2 ;
12351   void *arg3 = (void *) 0 ;
12352   int val1 ;
12353   int ecode1 = 0 ;
12354   int val2 ;
12355   int ecode2 = 0 ;
12356   int res3 ;
12357   Py_ssize_t size3 = 0 ;
12358   void *buf3 = 0 ;
12359   PyObject * obj0 = 0 ;
12360   PyObject * obj1 = 0 ;
12361   PyObject * obj2 = 0 ;
12362   
12363   if (!PyArg_ParseTuple(args,(char *)"OOO:plsmema",&obj0,&obj1,&obj2)) SWIG_fail;
12364   ecode1 = SWIG_AsVal_int(obj0, &val1);
12365   if (!SWIG_IsOK(ecode1)) {
12366     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'");
12367   } 
12368   arg1 = (PLINT)(val1);
12369   ecode2 = SWIG_AsVal_int(obj1, &val2);
12370   if (!SWIG_IsOK(ecode2)) {
12371     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'");
12372   } 
12373   arg2 = (PLINT)(val2);
12374   {
12375     res3 = PyObject_AsWriteBuffer(obj2, &buf3, &size3);
12376     if (res3<0) {
12377       PyErr_Clear();
12378       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem, SIZE)""'");
12379     }
12380     arg3 = (void *) buf3;
12381   }
12382   plsmema(arg1,arg2,arg3);
12383   resultobj = SWIG_Py_Void();
12384   return resultobj;
12385 fail:
12386   return NULL;
12387 }
12388 
12389 
12390 SWIGINTERN PyObject *_wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12391   PyObject *resultobj = 0;
12392   PLFLT arg1 ;
12393   PLFLT arg2 ;
12394   double val1 ;
12395   int ecode1 = 0 ;
12396   double val2 ;
12397   int ecode2 = 0 ;
12398   PyObject * obj0 = 0 ;
12399   PyObject * obj1 = 0 ;
12400   
12401   if (!PyArg_ParseTuple(args,(char *)"OO:plsmin",&obj0,&obj1)) SWIG_fail;
12402   ecode1 = SWIG_AsVal_double(obj0, &val1);
12403   if (!SWIG_IsOK(ecode1)) {
12404     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
12405   } 
12406   arg1 = (PLFLT)(val1);
12407   ecode2 = SWIG_AsVal_double(obj1, &val2);
12408   if (!SWIG_IsOK(ecode2)) {
12409     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
12410   } 
12411   arg2 = (PLFLT)(val2);
12412   plsmin(arg1,arg2);
12413   resultobj = SWIG_Py_Void();
12414   return resultobj;
12415 fail:
12416   return NULL;
12417 }
12418 
12419 
12420 SWIGINTERN PyObject *_wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12421   PyObject *resultobj = 0;
12422   PLINT arg1 ;
12423   int val1 ;
12424   int ecode1 = 0 ;
12425   PyObject * obj0 = 0 ;
12426   
12427   if (!PyArg_ParseTuple(args,(char *)"O:plsori",&obj0)) SWIG_fail;
12428   ecode1 = SWIG_AsVal_int(obj0, &val1);
12429   if (!SWIG_IsOK(ecode1)) {
12430     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
12431   } 
12432   arg1 = (PLINT)(val1);
12433   plsori(arg1);
12434   resultobj = SWIG_Py_Void();
12435   return resultobj;
12436 fail:
12437   return NULL;
12438 }
12439 
12440 
12441 SWIGINTERN PyObject *_wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12442   PyObject *resultobj = 0;
12443   PLFLT arg1 ;
12444   PLFLT arg2 ;
12445   PLINT arg3 ;
12446   PLINT arg4 ;
12447   PLINT arg5 ;
12448   PLINT arg6 ;
12449   double val1 ;
12450   int ecode1 = 0 ;
12451   double val2 ;
12452   int ecode2 = 0 ;
12453   int val3 ;
12454   int ecode3 = 0 ;
12455   int val4 ;
12456   int ecode4 = 0 ;
12457   int val5 ;
12458   int ecode5 = 0 ;
12459   int val6 ;
12460   int ecode6 = 0 ;
12461   PyObject * obj0 = 0 ;
12462   PyObject * obj1 = 0 ;
12463   PyObject * obj2 = 0 ;
12464   PyObject * obj3 = 0 ;
12465   PyObject * obj4 = 0 ;
12466   PyObject * obj5 = 0 ;
12467   
12468   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plspage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
12469   ecode1 = SWIG_AsVal_double(obj0, &val1);
12470   if (!SWIG_IsOK(ecode1)) {
12471     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
12472   } 
12473   arg1 = (PLFLT)(val1);
12474   ecode2 = SWIG_AsVal_double(obj1, &val2);
12475   if (!SWIG_IsOK(ecode2)) {
12476     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
12477   } 
12478   arg2 = (PLFLT)(val2);
12479   ecode3 = SWIG_AsVal_int(obj2, &val3);
12480   if (!SWIG_IsOK(ecode3)) {
12481     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
12482   } 
12483   arg3 = (PLINT)(val3);
12484   ecode4 = SWIG_AsVal_int(obj3, &val4);
12485   if (!SWIG_IsOK(ecode4)) {
12486     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
12487   } 
12488   arg4 = (PLINT)(val4);
12489   ecode5 = SWIG_AsVal_int(obj4, &val5);
12490   if (!SWIG_IsOK(ecode5)) {
12491     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
12492   } 
12493   arg5 = (PLINT)(val5);
12494   ecode6 = SWIG_AsVal_int(obj5, &val6);
12495   if (!SWIG_IsOK(ecode6)) {
12496     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
12497   } 
12498   arg6 = (PLINT)(val6);
12499   plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12500   resultobj = SWIG_Py_Void();
12501   return resultobj;
12502 fail:
12503   return NULL;
12504 }
12505 
12506 
12507 SWIGINTERN PyObject *_wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12508   PyObject *resultobj = 0;
12509   char *arg1 = (char *) 0 ;
12510   int res1 ;
12511   char *buf1 = 0 ;
12512   int alloc1 = 0 ;
12513   PyObject * obj0 = 0 ;
12514   
12515   if (!PyArg_ParseTuple(args,(char *)"O:plspal0",&obj0)) SWIG_fail;
12516   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12517   if (!SWIG_IsOK(res1)) {
12518     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
12519   }
12520   arg1 = (char *)(buf1);
12521   plspal0((char const *)arg1);
12522   resultobj = SWIG_Py_Void();
12523   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12524   return resultobj;
12525 fail:
12526   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12527   return NULL;
12528 }
12529 
12530 
12531 SWIGINTERN PyObject *_wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12532   PyObject *resultobj = 0;
12533   char *arg1 = (char *) 0 ;
12534   PLBOOL arg2 ;
12535   int res1 ;
12536   char *buf1 = 0 ;
12537   int alloc1 = 0 ;
12538   int val2 ;
12539   int ecode2 = 0 ;
12540   PyObject * obj0 = 0 ;
12541   PyObject * obj1 = 0 ;
12542   
12543   if (!PyArg_ParseTuple(args,(char *)"OO:plspal1",&obj0,&obj1)) SWIG_fail;
12544   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12545   if (!SWIG_IsOK(res1)) {
12546     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
12547   }
12548   arg1 = (char *)(buf1);
12549   ecode2 = SWIG_AsVal_int(obj1, &val2);
12550   if (!SWIG_IsOK(ecode2)) {
12551     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
12552   } 
12553   arg2 = (PLBOOL)(val2);
12554   plspal1((char const *)arg1,arg2);
12555   resultobj = SWIG_Py_Void();
12556   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12557   return resultobj;
12558 fail:
12559   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12560   return NULL;
12561 }
12562 
12563 
12564 SWIGINTERN PyObject *_wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12565   PyObject *resultobj = 0;
12566   PLBOOL arg1 ;
12567   int val1 ;
12568   int ecode1 = 0 ;
12569   PyObject * obj0 = 0 ;
12570   
12571   if (!PyArg_ParseTuple(args,(char *)"O:plspause",&obj0)) SWIG_fail;
12572   ecode1 = SWIG_AsVal_int(obj0, &val1);
12573   if (!SWIG_IsOK(ecode1)) {
12574     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
12575   } 
12576   arg1 = (PLBOOL)(val1);
12577   plspause(arg1);
12578   resultobj = SWIG_Py_Void();
12579   return resultobj;
12580 fail:
12581   return NULL;
12582 }
12583 
12584 
12585 SWIGINTERN PyObject *_wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12586   PyObject *resultobj = 0;
12587   PLINT arg1 ;
12588   int val1 ;
12589   int ecode1 = 0 ;
12590   PyObject * obj0 = 0 ;
12591   
12592   if (!PyArg_ParseTuple(args,(char *)"O:plsstrm",&obj0)) SWIG_fail;
12593   ecode1 = SWIG_AsVal_int(obj0, &val1);
12594   if (!SWIG_IsOK(ecode1)) {
12595     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
12596   } 
12597   arg1 = (PLINT)(val1);
12598   plsstrm(arg1);
12599   resultobj = SWIG_Py_Void();
12600   return resultobj;
12601 fail:
12602   return NULL;
12603 }
12604 
12605 
12606 SWIGINTERN PyObject *_wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12607   PyObject *resultobj = 0;
12608   PLINT arg1 ;
12609   PLINT arg2 ;
12610   int val1 ;
12611   int ecode1 = 0 ;
12612   int val2 ;
12613   int ecode2 = 0 ;
12614   PyObject * obj0 = 0 ;
12615   PyObject * obj1 = 0 ;
12616   
12617   if (!PyArg_ParseTuple(args,(char *)"OO:plssub",&obj0,&obj1)) SWIG_fail;
12618   ecode1 = SWIG_AsVal_int(obj0, &val1);
12619   if (!SWIG_IsOK(ecode1)) {
12620     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
12621   } 
12622   arg1 = (PLINT)(val1);
12623   ecode2 = SWIG_AsVal_int(obj1, &val2);
12624   if (!SWIG_IsOK(ecode2)) {
12625     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
12626   } 
12627   arg2 = (PLINT)(val2);
12628   plssub(arg1,arg2);
12629   resultobj = SWIG_Py_Void();
12630   return resultobj;
12631 fail:
12632   return NULL;
12633 }
12634 
12635 
12636 SWIGINTERN PyObject *_wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12637   PyObject *resultobj = 0;
12638   PLFLT arg1 ;
12639   PLFLT arg2 ;
12640   double val1 ;
12641   int ecode1 = 0 ;
12642   double val2 ;
12643   int ecode2 = 0 ;
12644   PyObject * obj0 = 0 ;
12645   PyObject * obj1 = 0 ;
12646   
12647   if (!PyArg_ParseTuple(args,(char *)"OO:plssym",&obj0,&obj1)) SWIG_fail;
12648   ecode1 = SWIG_AsVal_double(obj0, &val1);
12649   if (!SWIG_IsOK(ecode1)) {
12650     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
12651   } 
12652   arg1 = (PLFLT)(val1);
12653   ecode2 = SWIG_AsVal_double(obj1, &val2);
12654   if (!SWIG_IsOK(ecode2)) {
12655     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
12656   } 
12657   arg2 = (PLFLT)(val2);
12658   plssym(arg1,arg2);
12659   resultobj = SWIG_Py_Void();
12660   return resultobj;
12661 fail:
12662   return NULL;
12663 }
12664 
12665 
12666 SWIGINTERN PyObject *_wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12667   PyObject *resultobj = 0;
12668   PLINT arg1 ;
12669   PLINT arg2 ;
12670   int val1 ;
12671   int ecode1 = 0 ;
12672   int val2 ;
12673   int ecode2 = 0 ;
12674   PyObject * obj0 = 0 ;
12675   PyObject * obj1 = 0 ;
12676   
12677   if (!PyArg_ParseTuple(args,(char *)"OO:plstar",&obj0,&obj1)) SWIG_fail;
12678   ecode1 = SWIG_AsVal_int(obj0, &val1);
12679   if (!SWIG_IsOK(ecode1)) {
12680     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
12681   } 
12682   arg1 = (PLINT)(val1);
12683   ecode2 = SWIG_AsVal_int(obj1, &val2);
12684   if (!SWIG_IsOK(ecode2)) {
12685     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
12686   } 
12687   arg2 = (PLINT)(val2);
12688   plstar(arg1,arg2);
12689   resultobj = SWIG_Py_Void();
12690   return resultobj;
12691 fail:
12692   return NULL;
12693 }
12694 
12695 
12696 SWIGINTERN PyObject *_wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12697   PyObject *resultobj = 0;
12698   char *arg1 = (char *) 0 ;
12699   PLINT arg2 ;
12700   PLINT arg3 ;
12701   int res1 ;
12702   char *buf1 = 0 ;
12703   int alloc1 = 0 ;
12704   int val2 ;
12705   int ecode2 = 0 ;
12706   int val3 ;
12707   int ecode3 = 0 ;
12708   PyObject * obj0 = 0 ;
12709   PyObject * obj1 = 0 ;
12710   PyObject * obj2 = 0 ;
12711   
12712   if (!PyArg_ParseTuple(args,(char *)"OOO:plstart",&obj0,&obj1,&obj2)) SWIG_fail;
12713   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
12714   if (!SWIG_IsOK(res1)) {
12715     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
12716   }
12717   arg1 = (char *)(buf1);
12718   ecode2 = SWIG_AsVal_int(obj1, &val2);
12719   if (!SWIG_IsOK(ecode2)) {
12720     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
12721   } 
12722   arg2 = (PLINT)(val2);
12723   ecode3 = SWIG_AsVal_int(obj2, &val3);
12724   if (!SWIG_IsOK(ecode3)) {
12725     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
12726   } 
12727   arg3 = (PLINT)(val3);
12728   plstart((char const *)arg1,arg2,arg3);
12729   resultobj = SWIG_Py_Void();
12730   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12731   return resultobj;
12732 fail:
12733   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12734   return NULL;
12735 }
12736 
12737 
12738 SWIGINTERN PyObject *_wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12739   PyObject *resultobj = 0;
12740   ct_func arg1 = (ct_func) 0 ;
12741   PLPointer arg2 = (PLPointer) 0 ;
12742   int res2 ;
12743   PyObject * obj0 = 0 ;
12744   PyObject * obj1 = 0 ;
12745   
12746   {
12747     python_ct = 0;
12748     arg1        = NULL;
12749   }
12750   if (!PyArg_ParseTuple(args,(char *)"|OO:plstransform",&obj0,&obj1)) SWIG_fail;
12751   if (obj0) {
12752     {
12753       if ( python_ct )
12754       cleanup_ct();
12755       // it must be a callable or none
12756       if ( obj0 == Py_None )
12757       {
12758         arg1 = NULL;
12759       }
12760       else
12761       {
12762         if ( !PyCallable_Check( (PyObject *) obj0 ) )
12763         {
12764           PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" );
12765           return NULL;
12766         }
12767         arg1 = marshal_ct( obj0 );
12768       }
12769     }
12770   }
12771   if (obj1) {
12772     res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
12773     if (!SWIG_IsOK(res2)) {
12774       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'"); 
12775     }
12776   }
12777   plstransform(arg1,arg2);
12778   resultobj = SWIG_Py_Void();
12779   return resultobj;
12780 fail:
12781   return NULL;
12782 }
12783 
12784 
12785 SWIGINTERN PyObject *_wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12786   PyObject *resultobj = 0;
12787   PLINT arg1 ;
12788   PLFLT *arg2 = (PLFLT *) 0 ;
12789   PLFLT *arg3 = (PLFLT *) 0 ;
12790   char *arg4 = (char *) 0 ;
12791   PyArrayObject *tmp1 = NULL ;
12792   PyArrayObject *tmp3 = NULL ;
12793   int res4 ;
12794   char *buf4 = 0 ;
12795   int alloc4 = 0 ;
12796   PyObject * obj0 = 0 ;
12797   PyObject * obj1 = 0 ;
12798   PyObject * obj2 = 0 ;
12799   
12800   if (!PyArg_ParseTuple(args,(char *)"OOO:plstring",&obj0,&obj1,&obj2)) SWIG_fail;
12801   {
12802     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
12803     if ( tmp1 == NULL )
12804     return NULL;
12805     arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12806     arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12807   }
12808   {
12809     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
12810     if ( tmp3 == NULL )
12811     return NULL;
12812     if ( PyArray_DIMS( tmp3 )[0] != Alen )
12813     {
12814       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12815       return NULL;
12816     }
12817     arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12818   }
12819   res4 = SWIG_AsCharPtrAndSize(obj2, &buf4, NULL, &alloc4);
12820   if (!SWIG_IsOK(res4)) {
12821     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
12822   }
12823   arg4 = (char *)(buf4);
12824   plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
12825   resultobj = SWIG_Py_Void();
12826   {
12827     Py_CLEAR( tmp1 );
12828   }
12829   {
12830     Py_CLEAR( tmp3 );
12831   }
12832   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12833   return resultobj;
12834 fail:
12835   {
12836     Py_CLEAR( tmp1 );
12837   }
12838   {
12839     Py_CLEAR( tmp3 );
12840   }
12841   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12842   return NULL;
12843 }
12844 
12845 
12846 SWIGINTERN PyObject *_wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12847   PyObject *resultobj = 0;
12848   PLINT arg1 ;
12849   PLFLT *arg2 = (PLFLT *) 0 ;
12850   PLFLT *arg3 = (PLFLT *) 0 ;
12851   PLFLT *arg4 = (PLFLT *) 0 ;
12852   char *arg5 = (char *) 0 ;
12853   PyArrayObject *tmp1 = NULL ;
12854   PyArrayObject *tmp3 = NULL ;
12855   PyArrayObject *tmp4 = NULL ;
12856   int res5 ;
12857   char *buf5 = 0 ;
12858   int alloc5 = 0 ;
12859   PyObject * obj0 = 0 ;
12860   PyObject * obj1 = 0 ;
12861   PyObject * obj2 = 0 ;
12862   PyObject * obj3 = 0 ;
12863   
12864   if (!PyArg_ParseTuple(args,(char *)"OOOO:plstring3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12865   {
12866     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
12867     if ( tmp1 == NULL )
12868     return NULL;
12869     arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12870     arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12871   }
12872   {
12873     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
12874     if ( tmp3 == NULL )
12875     return NULL;
12876     if ( PyArray_DIMS( tmp3 )[0] != Alen )
12877     {
12878       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12879       return NULL;
12880     }
12881     arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12882   }
12883   {
12884     tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( obj2, NPY_PLFLT, 1, 1 );
12885     if ( tmp4 == NULL )
12886     return NULL;
12887     if ( PyArray_DIMS( tmp4 )[0] != Alen )
12888     {
12889       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12890       return NULL;
12891     }
12892     arg4 = (PLFLT *) PyArray_DATA( tmp4 );
12893   }
12894   res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, NULL, &alloc5);
12895   if (!SWIG_IsOK(res5)) {
12896     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
12897   }
12898   arg5 = (char *)(buf5);
12899   plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
12900   resultobj = SWIG_Py_Void();
12901   {
12902     Py_CLEAR( tmp1 );
12903   }
12904   {
12905     Py_CLEAR( tmp3 );
12906   }
12907   {
12908     Py_CLEAR( tmp4 );
12909   }
12910   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12911   return resultobj;
12912 fail:
12913   {
12914     Py_CLEAR( tmp1 );
12915   }
12916   {
12917     Py_CLEAR( tmp3 );
12918   }
12919   {
12920     Py_CLEAR( tmp4 );
12921   }
12922   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12923   return NULL;
12924 }
12925 
12926 
12927 SWIGINTERN PyObject *_wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12928   PyObject *resultobj = 0;
12929   PLINT arg1 ;
12930   PLINT arg2 ;
12931   PLFLT arg3 ;
12932   PLFLT arg4 ;
12933   int val1 ;
12934   int ecode1 = 0 ;
12935   int val2 ;
12936   int ecode2 = 0 ;
12937   double val3 ;
12938   int ecode3 = 0 ;
12939   double val4 ;
12940   int ecode4 = 0 ;
12941   PyObject * obj0 = 0 ;
12942   PyObject * obj1 = 0 ;
12943   PyObject * obj2 = 0 ;
12944   PyObject * obj3 = 0 ;
12945   
12946   if (!PyArg_ParseTuple(args,(char *)"OOOO:plstripa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12947   ecode1 = SWIG_AsVal_int(obj0, &val1);
12948   if (!SWIG_IsOK(ecode1)) {
12949     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
12950   } 
12951   arg1 = (PLINT)(val1);
12952   ecode2 = SWIG_AsVal_int(obj1, &val2);
12953   if (!SWIG_IsOK(ecode2)) {
12954     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
12955   } 
12956   arg2 = (PLINT)(val2);
12957   ecode3 = SWIG_AsVal_double(obj2, &val3);
12958   if (!SWIG_IsOK(ecode3)) {
12959     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
12960   } 
12961   arg3 = (PLFLT)(val3);
12962   ecode4 = SWIG_AsVal_double(obj3, &val4);
12963   if (!SWIG_IsOK(ecode4)) {
12964     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
12965   } 
12966   arg4 = (PLFLT)(val4);
12967   plstripa(arg1,arg2,arg3,arg4);
12968   resultobj = SWIG_Py_Void();
12969   return resultobj;
12970 fail:
12971   return NULL;
12972 }
12973 
12974 
12975 SWIGINTERN PyObject *_wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12976   PyObject *resultobj = 0;
12977   PLINT *arg1 = (PLINT *) 0 ;
12978   char *arg2 = (char *) 0 ;
12979   char *arg3 = (char *) 0 ;
12980   PLFLT arg4 ;
12981   PLFLT arg5 ;
12982   PLFLT arg6 ;
12983   PLFLT arg7 ;
12984   PLFLT arg8 ;
12985   PLFLT arg9 ;
12986   PLFLT arg10 ;
12987   PLBOOL arg11 ;
12988   PLBOOL arg12 ;
12989   PLINT arg13 ;
12990   PLINT arg14 ;
12991   PLINT *arg15 = (PLINT *) 0 ;
12992   PLINT *arg16 = (PLINT *) 0 ;
12993   char **arg17 ;
12994   char *arg18 = (char *) 0 ;
12995   char *arg19 = (char *) 0 ;
12996   char *arg20 = (char *) 0 ;
12997   PLINT temp1 ;
12998   int res1 = SWIG_TMPOBJ ;
12999   int res2 ;
13000   char *buf2 = 0 ;
13001   int alloc2 = 0 ;
13002   int res3 ;
13003   char *buf3 = 0 ;
13004   int alloc3 = 0 ;
13005   double val4 ;
13006   int ecode4 = 0 ;
13007   double val5 ;
13008   int ecode5 = 0 ;
13009   double val6 ;
13010   int ecode6 = 0 ;
13011   double val7 ;
13012   int ecode7 = 0 ;
13013   double val8 ;
13014   int ecode8 = 0 ;
13015   double val9 ;
13016   int ecode9 = 0 ;
13017   double val10 ;
13018   int ecode10 = 0 ;
13019   int val11 ;
13020   int ecode11 = 0 ;
13021   int val12 ;
13022   int ecode12 = 0 ;
13023   int val13 ;
13024   int ecode13 = 0 ;
13025   int val14 ;
13026   int ecode14 = 0 ;
13027   PyArrayObject *tmp15 = NULL ;
13028   PyArrayObject *tmp16 = NULL ;
13029   char **tmp17 = NULL ;
13030   int res18 ;
13031   char *buf18 = 0 ;
13032   int alloc18 = 0 ;
13033   int res19 ;
13034   char *buf19 = 0 ;
13035   int alloc19 = 0 ;
13036   int res20 ;
13037   char *buf20 = 0 ;
13038   int alloc20 = 0 ;
13039   PyObject * obj0 = 0 ;
13040   PyObject * obj1 = 0 ;
13041   PyObject * obj2 = 0 ;
13042   PyObject * obj3 = 0 ;
13043   PyObject * obj4 = 0 ;
13044   PyObject * obj5 = 0 ;
13045   PyObject * obj6 = 0 ;
13046   PyObject * obj7 = 0 ;
13047   PyObject * obj8 = 0 ;
13048   PyObject * obj9 = 0 ;
13049   PyObject * obj10 = 0 ;
13050   PyObject * obj11 = 0 ;
13051   PyObject * obj12 = 0 ;
13052   PyObject * obj13 = 0 ;
13053   PyObject * obj14 = 0 ;
13054   PyObject * obj15 = 0 ;
13055   PyObject * obj16 = 0 ;
13056   PyObject * obj17 = 0 ;
13057   PyObject * obj18 = 0 ;
13058   
13059   arg1 = &temp1;
13060   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:plstripc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
13061   res2 = SWIG_AsCharPtrAndSize(obj0, &buf2, NULL, &alloc2);
13062   if (!SWIG_IsOK(res2)) {
13063     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
13064   }
13065   arg2 = (char *)(buf2);
13066   res3 = SWIG_AsCharPtrAndSize(obj1, &buf3, NULL, &alloc3);
13067   if (!SWIG_IsOK(res3)) {
13068     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
13069   }
13070   arg3 = (char *)(buf3);
13071   ecode4 = SWIG_AsVal_double(obj2, &val4);
13072   if (!SWIG_IsOK(ecode4)) {
13073     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
13074   } 
13075   arg4 = (PLFLT)(val4);
13076   ecode5 = SWIG_AsVal_double(obj3, &val5);
13077   if (!SWIG_IsOK(ecode5)) {
13078     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
13079   } 
13080   arg5 = (PLFLT)(val5);
13081   ecode6 = SWIG_AsVal_double(obj4, &val6);
13082   if (!SWIG_IsOK(ecode6)) {
13083     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
13084   } 
13085   arg6 = (PLFLT)(val6);
13086   ecode7 = SWIG_AsVal_double(obj5, &val7);
13087   if (!SWIG_IsOK(ecode7)) {
13088     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
13089   } 
13090   arg7 = (PLFLT)(val7);
13091   ecode8 = SWIG_AsVal_double(obj6, &val8);
13092   if (!SWIG_IsOK(ecode8)) {
13093     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
13094   } 
13095   arg8 = (PLFLT)(val8);
13096   ecode9 = SWIG_AsVal_double(obj7, &val9);
13097   if (!SWIG_IsOK(ecode9)) {
13098     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
13099   } 
13100   arg9 = (PLFLT)(val9);
13101   ecode10 = SWIG_AsVal_double(obj8, &val10);
13102   if (!SWIG_IsOK(ecode10)) {
13103     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
13104   } 
13105   arg10 = (PLFLT)(val10);
13106   ecode11 = SWIG_AsVal_int(obj9, &val11);
13107   if (!SWIG_IsOK(ecode11)) {
13108     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
13109   } 
13110   arg11 = (PLBOOL)(val11);
13111   ecode12 = SWIG_AsVal_int(obj10, &val12);
13112   if (!SWIG_IsOK(ecode12)) {
13113     SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
13114   } 
13115   arg12 = (PLBOOL)(val12);
13116   ecode13 = SWIG_AsVal_int(obj11, &val13);
13117   if (!SWIG_IsOK(ecode13)) {
13118     SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
13119   } 
13120   arg13 = (PLINT)(val13);
13121   ecode14 = SWIG_AsVal_int(obj12, &val14);
13122   if (!SWIG_IsOK(ecode14)) {
13123     SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
13124   } 
13125   arg14 = (PLINT)(val14);
13126   {
13127     tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj13, NPY_PLINT, 1, 1 );
13128     if ( tmp15 == NULL )
13129     return NULL;
13130     Alen = PyArray_DIMS( tmp15 )[0];
13131     arg15   = (PLINT *) PyArray_DATA( tmp15 );
13132   }
13133   {
13134     tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj14, NPY_PLINT, 1, 1 );
13135     if ( tmp16 == NULL )
13136     return NULL;
13137     if ( PyArray_DIMS( tmp16 )[0] != Alen )
13138     {
13139       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13140       return NULL;
13141     }
13142     arg16 = (PLINT *) PyArray_DATA( tmp16 );
13143   }
13144   {
13145     int i;
13146     if ( !PySequence_Check( obj15 ) || PySequence_Size( obj15 ) != 4 )
13147     {
13148       PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." );
13149       return NULL;
13150     }
13151     if ( Alen != 4 )
13152     {
13153       PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." );
13154       return NULL;
13155     }
13156     tmp17 = (char **) malloc( sizeof ( char* ) * 4 );
13157     if ( tmp17 == NULL )
13158     return NULL;
13159     arg17 = tmp17;
13160     for ( i = 0; i < 4; i++ )
13161     {
13162       arg17[i] = PyString_AsString( PySequence_Fast_GET_ITEM( obj15, i ) );
13163       if ( arg17[i] == NULL )
13164       {
13165         free( tmp17 );
13166         return NULL;
13167       }
13168     }
13169   }
13170   res18 = SWIG_AsCharPtrAndSize(obj16, &buf18, NULL, &alloc18);
13171   if (!SWIG_IsOK(res18)) {
13172     SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
13173   }
13174   arg18 = (char *)(buf18);
13175   res19 = SWIG_AsCharPtrAndSize(obj17, &buf19, NULL, &alloc19);
13176   if (!SWIG_IsOK(res19)) {
13177     SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
13178   }
13179   arg19 = (char *)(buf19);
13180   res20 = SWIG_AsCharPtrAndSize(obj18, &buf20, NULL, &alloc20);
13181   if (!SWIG_IsOK(res20)) {
13182     SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
13183   }
13184   arg20 = (char *)(buf20);
13185   plstripc(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,(int const *)arg15,(int const *)arg16,(char const *(*))arg17,(char const *)arg18,(char const *)arg19,(char const *)arg20);
13186   resultobj = SWIG_Py_Void();
13187   if (SWIG_IsTmpObj(res1)) {
13188     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
13189   } else {
13190     int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
13191     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
13192   }
13193   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13194   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13195   {
13196     Py_CLEAR( tmp15 );
13197   }
13198   {
13199     Py_CLEAR( tmp16 );
13200   }
13201   {
13202     free( tmp17 );
13203   }
13204   if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13205   if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13206   if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13207   return resultobj;
13208 fail:
13209   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13210   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13211   {
13212     Py_CLEAR( tmp15 );
13213   }
13214   {
13215     Py_CLEAR( tmp16 );
13216   }
13217   {
13218     free( tmp17 );
13219   }
13220   if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13221   if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13222   if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13223   return NULL;
13224 }
13225 
13226 
13227 SWIGINTERN PyObject *_wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13228   PyObject *resultobj = 0;
13229   PLINT arg1 ;
13230   int val1 ;
13231   int ecode1 = 0 ;
13232   PyObject * obj0 = 0 ;
13233   
13234   if (!PyArg_ParseTuple(args,(char *)"O:plstripd",&obj0)) SWIG_fail;
13235   ecode1 = SWIG_AsVal_int(obj0, &val1);
13236   if (!SWIG_IsOK(ecode1)) {
13237     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
13238   } 
13239   arg1 = (PLINT)(val1);
13240   plstripd(arg1);
13241   resultobj = SWIG_Py_Void();
13242   return resultobj;
13243 fail:
13244   return NULL;
13245 }
13246 
13247 
13248 SWIGINTERN PyObject *_wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13249   PyObject *resultobj = 0;
13250   PLINT arg1 ;
13251   PLINT *arg2 = (PLINT *) 0 ;
13252   PLINT *arg3 = (PLINT *) 0 ;
13253   PyArrayObject *tmp1 = NULL ;
13254   PyArrayObject *tmp3 = NULL ;
13255   PyObject * obj0 = 0 ;
13256   PyObject * obj1 = 0 ;
13257   
13258   if (!PyArg_ParseTuple(args,(char *)"OO:plstyl",&obj0,&obj1)) SWIG_fail;
13259   {
13260     tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj0, NPY_PLINT, 1, 1 );
13261     if ( tmp1 == NULL )
13262     return NULL;
13263     arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13264     arg2 = (PLINT *) PyArray_DATA( tmp1 );
13265   }
13266   {
13267     tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( obj1, NPY_PLINT, 1, 1 );
13268     if ( tmp3 == NULL )
13269     return NULL;
13270     if ( PyArray_DIMS( tmp3 )[0] != Alen )
13271     {
13272       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13273       return NULL;
13274     }
13275     arg3 = (PLINT *) PyArray_DATA( tmp3 );
13276   }
13277   plstyl(arg1,(int const *)arg2,(int const *)arg3);
13278   resultobj = SWIG_Py_Void();
13279   {
13280     Py_CLEAR( tmp1 );
13281   }
13282   {
13283     Py_CLEAR( tmp3 );
13284   }
13285   return resultobj;
13286 fail:
13287   {
13288     Py_CLEAR( tmp1 );
13289   }
13290   {
13291     Py_CLEAR( tmp3 );
13292   }
13293   return NULL;
13294 }
13295 
13296 
13297 SWIGINTERN PyObject *_wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13298   PyObject *resultobj = 0;
13299   PLFLT *arg1 = (PLFLT *) 0 ;
13300   PLFLT *arg2 = (PLFLT *) 0 ;
13301   PLINT arg3 ;
13302   PLBOOL arg4 ;
13303   PyArrayObject *tmp1 = NULL ;
13304   PyArrayObject *tmp2 = NULL ;
13305   int val4 ;
13306   int ecode4 = 0 ;
13307   PyObject * obj0 = 0 ;
13308   PyObject * obj1 = 0 ;
13309   PyObject * obj2 = 0 ;
13310   
13311   if (!PyArg_ParseTuple(args,(char *)"OOO:plsvect",&obj0,&obj1,&obj2)) SWIG_fail;
13312   {
13313     if ( obj0 != Py_None )
13314     {
13315       tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
13316       if ( tmp1 == NULL )
13317       return NULL;
13318       Alen = PyArray_DIMS( tmp1 )[0];
13319       arg1   = (PLFLT *) PyArray_DATA( tmp1 );
13320     }
13321     else
13322     {
13323       arg1   = NULL;
13324       Alen = 0;
13325     }
13326   }
13327   {
13328     if ( obj1 != Py_None )
13329     {
13330       tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
13331       if ( tmp2 == NULL )
13332       return NULL;
13333       if ( PyArray_DIMS( tmp2 )[0] != Alen )
13334       {
13335         PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13336         return NULL;
13337       }
13338       arg2 = (PLFLT *) PyArray_DATA( tmp2 );
13339       arg3 = PyArray_DIMS( tmp2 )[0];
13340     }
13341     else
13342     {
13343       arg2 = NULL;
13344       arg3 = 0;
13345     }
13346   }
13347   ecode4 = SWIG_AsVal_int(obj2, &val4);
13348   if (!SWIG_IsOK(ecode4)) {
13349     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
13350   } 
13351   arg4 = (PLBOOL)(val4);
13352   plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
13353   resultobj = SWIG_Py_Void();
13354   {
13355     Py_CLEAR( tmp1 );
13356   }
13357   {
13358     Py_CLEAR( tmp2 );
13359   }
13360   return resultobj;
13361 fail:
13362   {
13363     Py_CLEAR( tmp1 );
13364   }
13365   {
13366     Py_CLEAR( tmp2 );
13367   }
13368   return NULL;
13369 }
13370 
13371 
13372 SWIGINTERN PyObject *_wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13373   PyObject *resultobj = 0;
13374   PLFLT arg1 ;
13375   PLFLT arg2 ;
13376   PLFLT arg3 ;
13377   PLFLT arg4 ;
13378   double val1 ;
13379   int ecode1 = 0 ;
13380   double val2 ;
13381   int ecode2 = 0 ;
13382   double val3 ;
13383   int ecode3 = 0 ;
13384   double val4 ;
13385   int ecode4 = 0 ;
13386   PyObject * obj0 = 0 ;
13387   PyObject * obj1 = 0 ;
13388   PyObject * obj2 = 0 ;
13389   PyObject * obj3 = 0 ;
13390   
13391   if (!PyArg_ParseTuple(args,(char *)"OOOO:plsvpa",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13392   ecode1 = SWIG_AsVal_double(obj0, &val1);
13393   if (!SWIG_IsOK(ecode1)) {
13394     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
13395   } 
13396   arg1 = (PLFLT)(val1);
13397   ecode2 = SWIG_AsVal_double(obj1, &val2);
13398   if (!SWIG_IsOK(ecode2)) {
13399     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
13400   } 
13401   arg2 = (PLFLT)(val2);
13402   ecode3 = SWIG_AsVal_double(obj2, &val3);
13403   if (!SWIG_IsOK(ecode3)) {
13404     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
13405   } 
13406   arg3 = (PLFLT)(val3);
13407   ecode4 = SWIG_AsVal_double(obj3, &val4);
13408   if (!SWIG_IsOK(ecode4)) {
13409     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
13410   } 
13411   arg4 = (PLFLT)(val4);
13412   plsvpa(arg1,arg2,arg3,arg4);
13413   resultobj = SWIG_Py_Void();
13414   return resultobj;
13415 fail:
13416   return NULL;
13417 }
13418 
13419 
13420 SWIGINTERN PyObject *_wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13421   PyObject *resultobj = 0;
13422   PLINT arg1 ;
13423   PLINT arg2 ;
13424   int val1 ;
13425   int ecode1 = 0 ;
13426   int val2 ;
13427   int ecode2 = 0 ;
13428   PyObject * obj0 = 0 ;
13429   PyObject * obj1 = 0 ;
13430   
13431   if (!PyArg_ParseTuple(args,(char *)"OO:plsxax",&obj0,&obj1)) SWIG_fail;
13432   ecode1 = SWIG_AsVal_int(obj0, &val1);
13433   if (!SWIG_IsOK(ecode1)) {
13434     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
13435   } 
13436   arg1 = (PLINT)(val1);
13437   ecode2 = SWIG_AsVal_int(obj1, &val2);
13438   if (!SWIG_IsOK(ecode2)) {
13439     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
13440   } 
13441   arg2 = (PLINT)(val2);
13442   plsxax(arg1,arg2);
13443   resultobj = SWIG_Py_Void();
13444   return resultobj;
13445 fail:
13446   return NULL;
13447 }
13448 
13449 
13450 SWIGINTERN PyObject *_wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13451   PyObject *resultobj = 0;
13452   PLINT arg1 ;
13453   PLINT arg2 ;
13454   int val1 ;
13455   int ecode1 = 0 ;
13456   int val2 ;
13457   int ecode2 = 0 ;
13458   PyObject * obj0 = 0 ;
13459   PyObject * obj1 = 0 ;
13460   
13461   if (!PyArg_ParseTuple(args,(char *)"OO:plsyax",&obj0,&obj1)) SWIG_fail;
13462   ecode1 = SWIG_AsVal_int(obj0, &val1);
13463   if (!SWIG_IsOK(ecode1)) {
13464     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
13465   } 
13466   arg1 = (PLINT)(val1);
13467   ecode2 = SWIG_AsVal_int(obj1, &val2);
13468   if (!SWIG_IsOK(ecode2)) {
13469     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
13470   } 
13471   arg2 = (PLINT)(val2);
13472   plsyax(arg1,arg2);
13473   resultobj = SWIG_Py_Void();
13474   return resultobj;
13475 fail:
13476   return NULL;
13477 }
13478 
13479 
13480 SWIGINTERN PyObject *_wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13481   PyObject *resultobj = 0;
13482   PLINT arg1 ;
13483   PLFLT *arg2 = (PLFLT *) 0 ;
13484   PLFLT *arg3 = (PLFLT *) 0 ;
13485   PLINT arg4 ;
13486   PyArrayObject *tmp1 = NULL ;
13487   PyArrayObject *tmp3 = NULL ;
13488   int val4 ;
13489   int ecode4 = 0 ;
13490   PyObject * obj0 = 0 ;
13491   PyObject * obj1 = 0 ;
13492   PyObject * obj2 = 0 ;
13493   
13494   if (!PyArg_ParseTuple(args,(char *)"OOO:plsym",&obj0,&obj1,&obj2)) SWIG_fail;
13495   {
13496     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 1, 1 );
13497     if ( tmp1 == NULL )
13498     return NULL;
13499     arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13500     arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13501   }
13502   {
13503     tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 1, 1 );
13504     if ( tmp3 == NULL )
13505     return NULL;
13506     if ( PyArray_DIMS( tmp3 )[0] != Alen )
13507     {
13508       PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13509       return NULL;
13510     }
13511     arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13512   }
13513   ecode4 = SWIG_AsVal_int(obj2, &val4);
13514   if (!SWIG_IsOK(ecode4)) {
13515     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
13516   } 
13517   arg4 = (PLINT)(val4);
13518   plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
13519   resultobj = SWIG_Py_Void();
13520   {
13521     Py_CLEAR( tmp1 );
13522   }
13523   {
13524     Py_CLEAR( tmp3 );
13525   }
13526   return resultobj;
13527 fail:
13528   {
13529     Py_CLEAR( tmp1 );
13530   }
13531   {
13532     Py_CLEAR( tmp3 );
13533   }
13534   return NULL;
13535 }
13536 
13537 
13538 SWIGINTERN PyObject *_wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13539   PyObject *resultobj = 0;
13540   PLINT arg1 ;
13541   PLINT arg2 ;
13542   int val1 ;
13543   int ecode1 = 0 ;
13544   int val2 ;
13545   int ecode2 = 0 ;
13546   PyObject * obj0 = 0 ;
13547   PyObject * obj1 = 0 ;
13548   
13549   if (!PyArg_ParseTuple(args,(char *)"OO:plszax",&obj0,&obj1)) SWIG_fail;
13550   ecode1 = SWIG_AsVal_int(obj0, &val1);
13551   if (!SWIG_IsOK(ecode1)) {
13552     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
13553   } 
13554   arg1 = (PLINT)(val1);
13555   ecode2 = SWIG_AsVal_int(obj1, &val2);
13556   if (!SWIG_IsOK(ecode2)) {
13557     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
13558   } 
13559   arg2 = (PLINT)(val2);
13560   plszax(arg1,arg2);
13561   resultobj = SWIG_Py_Void();
13562   return resultobj;
13563 fail:
13564   return NULL;
13565 }
13566 
13567 
13568 SWIGINTERN PyObject *_wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13569   PyObject *resultobj = 0;
13570   
13571   if (!PyArg_ParseTuple(args,(char *)":pltext")) SWIG_fail;
13572   pltext();
13573   resultobj = SWIG_Py_Void();
13574   return resultobj;
13575 fail:
13576   return NULL;
13577 }
13578 
13579 
13580 SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13581   PyObject *resultobj = 0;
13582   char *arg1 = (char *) 0 ;
13583   int res1 ;
13584   char *buf1 = 0 ;
13585   int alloc1 = 0 ;
13586   PyObject * obj0 = 0 ;
13587   
13588   if (!PyArg_ParseTuple(args,(char *)"O:pltimefmt",&obj0)) SWIG_fail;
13589   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
13590   if (!SWIG_IsOK(res1)) {
13591     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
13592   }
13593   arg1 = (char *)(buf1);
13594   pltimefmt((char const *)arg1);
13595   resultobj = SWIG_Py_Void();
13596   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13597   return resultobj;
13598 fail:
13599   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13600   return NULL;
13601 }
13602 
13603 
13604 SWIGINTERN PyObject *_wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13605   PyObject *resultobj = 0;
13606   PLFLT arg1 ;
13607   double val1 ;
13608   int ecode1 = 0 ;
13609   PyObject * obj0 = 0 ;
13610   
13611   if (!PyArg_ParseTuple(args,(char *)"O:plvasp",&obj0)) SWIG_fail;
13612   ecode1 = SWIG_AsVal_double(obj0, &val1);
13613   if (!SWIG_IsOK(ecode1)) {
13614     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
13615   } 
13616   arg1 = (PLFLT)(val1);
13617   plvasp(arg1);
13618   resultobj = SWIG_Py_Void();
13619   return resultobj;
13620 fail:
13621   return NULL;
13622 }
13623 
13624 
13625 SWIGINTERN PyObject *_wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13626   PyObject *resultobj = 0;
13627   PLFLT **arg1 = (PLFLT **) 0 ;
13628   PLFLT **arg2 = (PLFLT **) 0 ;
13629   PLINT arg3 ;
13630   PLINT arg4 ;
13631   PLFLT arg5 ;
13632   pltr_func arg6 = (pltr_func) 0 ;
13633   PLPointer arg7 = (PLPointer) 0 ;
13634   PyArrayObject *tmp1 = NULL ;
13635   PyArrayObject *tmp2 = NULL ;
13636   double val5 ;
13637   int ecode5 = 0 ;
13638   PyObject * obj0 = 0 ;
13639   PyObject * obj1 = 0 ;
13640   PyObject * obj2 = 0 ;
13641   PyObject * obj3 = 0 ;
13642   PyObject * obj4 = 0 ;
13643   
13644   {
13645     python_pltr = 0;
13646     arg6          = NULL;
13647   }
13648   {
13649     arg7 = NULL;
13650   }
13651   if (!PyArg_ParseTuple(args,(char *)"OOO|OO:plvect",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13652   {
13653     int i, size;
13654     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
13655     if ( tmp1 == NULL )
13656     return NULL;
13657     Xlen = PyArray_DIMS( tmp1 )[0];
13658     Ylen = PyArray_DIMS( tmp1 )[1];
13659     size = Ylen;
13660     arg1   = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
13661     for ( i = 0; i < Xlen; i++ )
13662     arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
13663   }
13664   {
13665     int i, size;
13666     tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( obj1, NPY_PLFLT, 2, 2 );
13667     if ( tmp2 == NULL )
13668     return NULL;
13669     if ( Xlen != PyArray_DIMS( tmp2 )[0] || Ylen != PyArray_DIMS( tmp2 )[1] )
13670     {
13671       PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
13672       return NULL;
13673     }
13674     arg3   = PyArray_DIMS( tmp2 )[0];
13675     arg4   = PyArray_DIMS( tmp2 )[1];
13676     size = arg4;
13677     arg2   = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg3 );
13678     for ( i = 0; i < arg3; i++ )
13679     arg2[i] = ( (PLFLT *) PyArray_DATA( tmp2 ) + i * size );
13680   }
13681   ecode5 = SWIG_AsVal_double(obj2, &val5);
13682   if (!SWIG_IsOK(ecode5)) {
13683     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13684   } 
13685   arg5 = (PLFLT)(val5);
13686   if (obj3) {
13687     {
13688       // it must be a callable or None
13689       if ( obj3 == Py_None )
13690       {
13691         arg6 = NULL;
13692       }
13693       else
13694       {
13695         if ( !PyCallable_Check( (PyObject *) obj3 ) )
13696         {
13697           PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
13698           return NULL;
13699         }
13700         arg6 = marshal_pltr( obj3 );
13701       }
13702     }
13703   }
13704   if (obj4) {
13705     {
13706       if ( obj4 == Py_None )
13707       arg7 = NULL;
13708       else
13709       {
13710         arg7 = marshal_PLPointer( obj4, 0 );
13711       }
13712     }
13713   }
13714   plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13715   resultobj = SWIG_Py_Void();
13716   {
13717     Py_CLEAR( tmp1 );
13718     free( arg1 );
13719   }
13720   {
13721     Py_CLEAR( tmp2 );
13722     free( arg2 );
13723   }
13724   {
13725     cleanup_pltr();
13726   }
13727   {
13728     cleanup_PLPointer();
13729   }
13730   return resultobj;
13731 fail:
13732   {
13733     Py_CLEAR( tmp1 );
13734     free( arg1 );
13735   }
13736   {
13737     Py_CLEAR( tmp2 );
13738     free( arg2 );
13739   }
13740   {
13741     cleanup_pltr();
13742   }
13743   {
13744     cleanup_PLPointer();
13745   }
13746   return NULL;
13747 }
13748 
13749 
13750 SWIGINTERN PyObject *_wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13751   PyObject *resultobj = 0;
13752   PLFLT arg1 ;
13753   PLFLT arg2 ;
13754   PLFLT arg3 ;
13755   PLFLT arg4 ;
13756   PLFLT arg5 ;
13757   double val1 ;
13758   int ecode1 = 0 ;
13759   double val2 ;
13760   int ecode2 = 0 ;
13761   double val3 ;
13762   int ecode3 = 0 ;
13763   double val4 ;
13764   int ecode4 = 0 ;
13765   double val5 ;
13766   int ecode5 = 0 ;
13767   PyObject * obj0 = 0 ;
13768   PyObject * obj1 = 0 ;
13769   PyObject * obj2 = 0 ;
13770   PyObject * obj3 = 0 ;
13771   PyObject * obj4 = 0 ;
13772   
13773   if (!PyArg_ParseTuple(args,(char *)"OOOOO:plvpas",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13774   ecode1 = SWIG_AsVal_double(obj0, &val1);
13775   if (!SWIG_IsOK(ecode1)) {
13776     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
13777   } 
13778   arg1 = (PLFLT)(val1);
13779   ecode2 = SWIG_AsVal_double(obj1, &val2);
13780   if (!SWIG_IsOK(ecode2)) {
13781     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
13782   } 
13783   arg2 = (PLFLT)(val2);
13784   ecode3 = SWIG_AsVal_double(obj2, &val3);
13785   if (!SWIG_IsOK(ecode3)) {
13786     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
13787   } 
13788   arg3 = (PLFLT)(val3);
13789   ecode4 = SWIG_AsVal_double(obj3, &val4);
13790   if (!SWIG_IsOK(ecode4)) {
13791     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
13792   } 
13793   arg4 = (PLFLT)(val4);
13794   ecode5 = SWIG_AsVal_double(obj4, &val5);
13795   if (!SWIG_IsOK(ecode5)) {
13796     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
13797   } 
13798   arg5 = (PLFLT)(val5);
13799   plvpas(arg1,arg2,arg3,arg4,arg5);
13800   resultobj = SWIG_Py_Void();
13801   return resultobj;
13802 fail:
13803   return NULL;
13804 }
13805 
13806 
13807 SWIGINTERN PyObject *_wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13808   PyObject *resultobj = 0;
13809   PLFLT arg1 ;
13810   PLFLT arg2 ;
13811   PLFLT arg3 ;
13812   PLFLT arg4 ;
13813   double val1 ;
13814   int ecode1 = 0 ;
13815   double val2 ;
13816   int ecode2 = 0 ;
13817   double val3 ;
13818   int ecode3 = 0 ;
13819   double val4 ;
13820   int ecode4 = 0 ;
13821   PyObject * obj0 = 0 ;
13822   PyObject * obj1 = 0 ;
13823   PyObject * obj2 = 0 ;
13824   PyObject * obj3 = 0 ;
13825   
13826   if (!PyArg_ParseTuple(args,(char *)"OOOO:plvpor",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13827   ecode1 = SWIG_AsVal_double(obj0, &val1);
13828   if (!SWIG_IsOK(ecode1)) {
13829     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
13830   } 
13831   arg1 = (PLFLT)(val1);
13832   ecode2 = SWIG_AsVal_double(obj1, &val2);
13833   if (!SWIG_IsOK(ecode2)) {
13834     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
13835   } 
13836   arg2 = (PLFLT)(val2);
13837   ecode3 = SWIG_AsVal_double(obj2, &val3);
13838   if (!SWIG_IsOK(ecode3)) {
13839     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
13840   } 
13841   arg3 = (PLFLT)(val3);
13842   ecode4 = SWIG_AsVal_double(obj3, &val4);
13843   if (!SWIG_IsOK(ecode4)) {
13844     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
13845   } 
13846   arg4 = (PLFLT)(val4);
13847   plvpor(arg1,arg2,arg3,arg4);
13848   resultobj = SWIG_Py_Void();
13849   return resultobj;
13850 fail:
13851   return NULL;
13852 }
13853 
13854 
13855 SWIGINTERN PyObject *_wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13856   PyObject *resultobj = 0;
13857   
13858   if (!PyArg_ParseTuple(args,(char *)":plvsta")) SWIG_fail;
13859   plvsta();
13860   resultobj = SWIG_Py_Void();
13861   return resultobj;
13862 fail:
13863   return NULL;
13864 }
13865 
13866 
13867 SWIGINTERN PyObject *_wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13868   PyObject *resultobj = 0;
13869   PLFLT arg1 ;
13870   PLFLT arg2 ;
13871   PLFLT arg3 ;
13872   PLFLT arg4 ;
13873   PLFLT arg5 ;
13874   PLFLT arg6 ;
13875   PLFLT arg7 ;
13876   PLFLT arg8 ;
13877   PLFLT arg9 ;
13878   PLFLT arg10 ;
13879   PLFLT arg11 ;
13880   double val1 ;
13881   int ecode1 = 0 ;
13882   double val2 ;
13883   int ecode2 = 0 ;
13884   double val3 ;
13885   int ecode3 = 0 ;
13886   double val4 ;
13887   int ecode4 = 0 ;
13888   double val5 ;
13889   int ecode5 = 0 ;
13890   double val6 ;
13891   int ecode6 = 0 ;
13892   double val7 ;
13893   int ecode7 = 0 ;
13894   double val8 ;
13895   int ecode8 = 0 ;
13896   double val9 ;
13897   int ecode9 = 0 ;
13898   double val10 ;
13899   int ecode10 = 0 ;
13900   double val11 ;
13901   int ecode11 = 0 ;
13902   PyObject * obj0 = 0 ;
13903   PyObject * obj1 = 0 ;
13904   PyObject * obj2 = 0 ;
13905   PyObject * obj3 = 0 ;
13906   PyObject * obj4 = 0 ;
13907   PyObject * obj5 = 0 ;
13908   PyObject * obj6 = 0 ;
13909   PyObject * obj7 = 0 ;
13910   PyObject * obj8 = 0 ;
13911   PyObject * obj9 = 0 ;
13912   PyObject * obj10 = 0 ;
13913   
13914   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plw3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
13915   ecode1 = SWIG_AsVal_double(obj0, &val1);
13916   if (!SWIG_IsOK(ecode1)) {
13917     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
13918   } 
13919   arg1 = (PLFLT)(val1);
13920   ecode2 = SWIG_AsVal_double(obj1, &val2);
13921   if (!SWIG_IsOK(ecode2)) {
13922     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
13923   } 
13924   arg2 = (PLFLT)(val2);
13925   ecode3 = SWIG_AsVal_double(obj2, &val3);
13926   if (!SWIG_IsOK(ecode3)) {
13927     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
13928   } 
13929   arg3 = (PLFLT)(val3);
13930   ecode4 = SWIG_AsVal_double(obj3, &val4);
13931   if (!SWIG_IsOK(ecode4)) {
13932     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
13933   } 
13934   arg4 = (PLFLT)(val4);
13935   ecode5 = SWIG_AsVal_double(obj4, &val5);
13936   if (!SWIG_IsOK(ecode5)) {
13937     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
13938   } 
13939   arg5 = (PLFLT)(val5);
13940   ecode6 = SWIG_AsVal_double(obj5, &val6);
13941   if (!SWIG_IsOK(ecode6)) {
13942     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
13943   } 
13944   arg6 = (PLFLT)(val6);
13945   ecode7 = SWIG_AsVal_double(obj6, &val7);
13946   if (!SWIG_IsOK(ecode7)) {
13947     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
13948   } 
13949   arg7 = (PLFLT)(val7);
13950   ecode8 = SWIG_AsVal_double(obj7, &val8);
13951   if (!SWIG_IsOK(ecode8)) {
13952     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
13953   } 
13954   arg8 = (PLFLT)(val8);
13955   ecode9 = SWIG_AsVal_double(obj8, &val9);
13956   if (!SWIG_IsOK(ecode9)) {
13957     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
13958   } 
13959   arg9 = (PLFLT)(val9);
13960   ecode10 = SWIG_AsVal_double(obj9, &val10);
13961   if (!SWIG_IsOK(ecode10)) {
13962     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
13963   } 
13964   arg10 = (PLFLT)(val10);
13965   ecode11 = SWIG_AsVal_double(obj10, &val11);
13966   if (!SWIG_IsOK(ecode11)) {
13967     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
13968   } 
13969   arg11 = (PLFLT)(val11);
13970   plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13971   resultobj = SWIG_Py_Void();
13972   return resultobj;
13973 fail:
13974   return NULL;
13975 }
13976 
13977 
13978 SWIGINTERN PyObject *_wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13979   PyObject *resultobj = 0;
13980   PLFLT arg1 ;
13981   double val1 ;
13982   int ecode1 = 0 ;
13983   PyObject * obj0 = 0 ;
13984   
13985   if (!PyArg_ParseTuple(args,(char *)"O:plwidth",&obj0)) SWIG_fail;
13986   ecode1 = SWIG_AsVal_double(obj0, &val1);
13987   if (!SWIG_IsOK(ecode1)) {
13988     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
13989   } 
13990   arg1 = (PLFLT)(val1);
13991   plwidth(arg1);
13992   resultobj = SWIG_Py_Void();
13993   return resultobj;
13994 fail:
13995   return NULL;
13996 }
13997 
13998 
13999 SWIGINTERN PyObject *_wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14000   PyObject *resultobj = 0;
14001   PLFLT arg1 ;
14002   PLFLT arg2 ;
14003   PLFLT arg3 ;
14004   PLFLT arg4 ;
14005   double val1 ;
14006   int ecode1 = 0 ;
14007   double val2 ;
14008   int ecode2 = 0 ;
14009   double val3 ;
14010   int ecode3 = 0 ;
14011   double val4 ;
14012   int ecode4 = 0 ;
14013   PyObject * obj0 = 0 ;
14014   PyObject * obj1 = 0 ;
14015   PyObject * obj2 = 0 ;
14016   PyObject * obj3 = 0 ;
14017   
14018   if (!PyArg_ParseTuple(args,(char *)"OOOO:plwind",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14019   ecode1 = SWIG_AsVal_double(obj0, &val1);
14020   if (!SWIG_IsOK(ecode1)) {
14021     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
14022   } 
14023   arg1 = (PLFLT)(val1);
14024   ecode2 = SWIG_AsVal_double(obj1, &val2);
14025   if (!SWIG_IsOK(ecode2)) {
14026     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
14027   } 
14028   arg2 = (PLFLT)(val2);
14029   ecode3 = SWIG_AsVal_double(obj2, &val3);
14030   if (!SWIG_IsOK(ecode3)) {
14031     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
14032   } 
14033   arg3 = (PLFLT)(val3);
14034   ecode4 = SWIG_AsVal_double(obj3, &val4);
14035   if (!SWIG_IsOK(ecode4)) {
14036     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
14037   } 
14038   arg4 = (PLFLT)(val4);
14039   plwind(arg1,arg2,arg3,arg4);
14040   resultobj = SWIG_Py_Void();
14041   return resultobj;
14042 fail:
14043   return NULL;
14044 }
14045 
14046 
14047 SWIGINTERN PyObject *_wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14048   PyObject *resultobj = 0;
14049   PLBOOL arg1 ;
14050   PLBOOL *arg2 = (PLBOOL *) 0 ;
14051   int val1 ;
14052   int ecode1 = 0 ;
14053   PLBOOL temp2 ;
14054   int res2 = SWIG_TMPOBJ ;
14055   PyObject * obj0 = 0 ;
14056   
14057   arg2 = &temp2;
14058   if (!PyArg_ParseTuple(args,(char *)"O:plxormod",&obj0)) SWIG_fail;
14059   ecode1 = SWIG_AsVal_int(obj0, &val1);
14060   if (!SWIG_IsOK(ecode1)) {
14061     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
14062   } 
14063   arg1 = (PLBOOL)(val1);
14064   plxormod(arg1,arg2);
14065   resultobj = SWIG_Py_Void();
14066   if (SWIG_IsTmpObj(res2)) {
14067     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
14068   } else {
14069     int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
14070     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
14071   }
14072   return resultobj;
14073 fail:
14074   return NULL;
14075 }
14076 
14077 
14078 SWIGINTERN PyObject *_wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14079   PyObject *resultobj = 0;
14080   mapform_func arg1 = (mapform_func) 0 ;
14081   char *arg2 = (char *) 0 ;
14082   PLFLT arg3 ;
14083   PLFLT arg4 ;
14084   PLFLT arg5 ;
14085   PLFLT arg6 ;
14086   int res2 ;
14087   char *buf2 = 0 ;
14088   int alloc2 = 0 ;
14089   double val3 ;
14090   int ecode3 = 0 ;
14091   double val4 ;
14092   int ecode4 = 0 ;
14093   double val5 ;
14094   int ecode5 = 0 ;
14095   double val6 ;
14096   int ecode6 = 0 ;
14097   PyObject * obj0 = 0 ;
14098   PyObject * obj1 = 0 ;
14099   PyObject * obj2 = 0 ;
14100   PyObject * obj3 = 0 ;
14101   PyObject * obj4 = 0 ;
14102   PyObject * obj5 = 0 ;
14103   
14104   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:plmap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14105   {
14106     // it must be a callable or none
14107     if ( obj0 == Py_None )
14108     {
14109       arg1 = NULL;
14110     }
14111     else
14112     {
14113       if ( !PyCallable_Check( (PyObject *) obj0 ) )
14114       {
14115         PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14116         return NULL;
14117       }
14118       arg1 = marshal_mapform( obj0 );
14119     }
14120   }
14121   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14122   if (!SWIG_IsOK(res2)) {
14123     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
14124   }
14125   arg2 = (char *)(buf2);
14126   ecode3 = SWIG_AsVal_double(obj2, &val3);
14127   if (!SWIG_IsOK(ecode3)) {
14128     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
14129   } 
14130   arg3 = (PLFLT)(val3);
14131   ecode4 = SWIG_AsVal_double(obj3, &val4);
14132   if (!SWIG_IsOK(ecode4)) {
14133     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
14134   } 
14135   arg4 = (PLFLT)(val4);
14136   ecode5 = SWIG_AsVal_double(obj4, &val5);
14137   if (!SWIG_IsOK(ecode5)) {
14138     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
14139   } 
14140   arg5 = (PLFLT)(val5);
14141   ecode6 = SWIG_AsVal_double(obj5, &val6);
14142   if (!SWIG_IsOK(ecode6)) {
14143     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
14144   } 
14145   arg6 = (PLFLT)(val6);
14146   plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
14147   resultobj = SWIG_Py_Void();
14148   {
14149     cleanup_mapform();
14150   }
14151   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14152   return resultobj;
14153 fail:
14154   {
14155     cleanup_mapform();
14156   }
14157   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14158   return NULL;
14159 }
14160 
14161 
14162 SWIGINTERN PyObject *_wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14163   PyObject *resultobj = 0;
14164   mapform_func arg1 = (mapform_func) 0 ;
14165   PLFLT arg2 ;
14166   PLFLT arg3 ;
14167   PLFLT arg4 ;
14168   PLFLT arg5 ;
14169   PLFLT arg6 ;
14170   PLFLT arg7 ;
14171   double val2 ;
14172   int ecode2 = 0 ;
14173   double val3 ;
14174   int ecode3 = 0 ;
14175   double val4 ;
14176   int ecode4 = 0 ;
14177   double val5 ;
14178   int ecode5 = 0 ;
14179   double val6 ;
14180   int ecode6 = 0 ;
14181   double val7 ;
14182   int ecode7 = 0 ;
14183   PyObject * obj0 = 0 ;
14184   PyObject * obj1 = 0 ;
14185   PyObject * obj2 = 0 ;
14186   PyObject * obj3 = 0 ;
14187   PyObject * obj4 = 0 ;
14188   PyObject * obj5 = 0 ;
14189   PyObject * obj6 = 0 ;
14190   
14191   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:plmeridians",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
14192   {
14193     // it must be a callable or none
14194     if ( obj0 == Py_None )
14195     {
14196       arg1 = NULL;
14197     }
14198     else
14199     {
14200       if ( !PyCallable_Check( (PyObject *) obj0 ) )
14201       {
14202         PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14203         return NULL;
14204       }
14205       arg1 = marshal_mapform( obj0 );
14206     }
14207   }
14208   ecode2 = SWIG_AsVal_double(obj1, &val2);
14209   if (!SWIG_IsOK(ecode2)) {
14210     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
14211   } 
14212   arg2 = (PLFLT)(val2);
14213   ecode3 = SWIG_AsVal_double(obj2, &val3);
14214   if (!SWIG_IsOK(ecode3)) {
14215     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
14216   } 
14217   arg3 = (PLFLT)(val3);
14218   ecode4 = SWIG_AsVal_double(obj3, &val4);
14219   if (!SWIG_IsOK(ecode4)) {
14220     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
14221   } 
14222   arg4 = (PLFLT)(val4);
14223   ecode5 = SWIG_AsVal_double(obj4, &val5);
14224   if (!SWIG_IsOK(ecode5)) {
14225     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
14226   } 
14227   arg5 = (PLFLT)(val5);
14228   ecode6 = SWIG_AsVal_double(obj5, &val6);
14229   if (!SWIG_IsOK(ecode6)) {
14230     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
14231   } 
14232   arg6 = (PLFLT)(val6);
14233   ecode7 = SWIG_AsVal_double(obj6, &val7);
14234   if (!SWIG_IsOK(ecode7)) {
14235     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
14236   } 
14237   arg7 = (PLFLT)(val7);
14238   plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
14239   resultobj = SWIG_Py_Void();
14240   {
14241     cleanup_mapform();
14242   }
14243   return resultobj;
14244 fail:
14245   {
14246     cleanup_mapform();
14247   }
14248   return NULL;
14249 }
14250 
14251 
14252 SWIGINTERN PyObject *_wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14253   PyObject *resultobj = 0;
14254   PLFLT **arg1 = (PLFLT **) 0 ;
14255   PLINT arg2 ;
14256   PLINT arg3 ;
14257   PLFLT arg4 ;
14258   PLFLT arg5 ;
14259   PLFLT arg6 ;
14260   PLFLT arg7 ;
14261   PLFLT arg8 ;
14262   PLFLT arg9 ;
14263   PLFLT arg10 ;
14264   PLFLT arg11 ;
14265   PLFLT arg12 ;
14266   PLFLT arg13 ;
14267   PyArrayObject *tmp1 = NULL ;
14268   double val4 ;
14269   int ecode4 = 0 ;
14270   double val5 ;
14271   int ecode5 = 0 ;
14272   double val6 ;
14273   int ecode6 = 0 ;
14274   double val7 ;
14275   int ecode7 = 0 ;
14276   double val8 ;
14277   int ecode8 = 0 ;
14278   double val9 ;
14279   int ecode9 = 0 ;
14280   double val10 ;
14281   int ecode10 = 0 ;
14282   double val11 ;
14283   int ecode11 = 0 ;
14284   double val12 ;
14285   int ecode12 = 0 ;
14286   double val13 ;
14287   int ecode13 = 0 ;
14288   PyObject * obj0 = 0 ;
14289   PyObject * obj1 = 0 ;
14290   PyObject * obj2 = 0 ;
14291   PyObject * obj3 = 0 ;
14292   PyObject * obj4 = 0 ;
14293   PyObject * obj5 = 0 ;
14294   PyObject * obj6 = 0 ;
14295   PyObject * obj7 = 0 ;
14296   PyObject * obj8 = 0 ;
14297   PyObject * obj9 = 0 ;
14298   PyObject * obj10 = 0 ;
14299   
14300   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:plimage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
14301   {
14302     int i, size;
14303     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
14304     if ( tmp1 == NULL )
14305     return NULL;
14306     Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14307     Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14308     size = arg3;
14309     arg1   = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14310     for ( i = 0; i < arg2; i++ )
14311     arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14312   }
14313   ecode4 = SWIG_AsVal_double(obj1, &val4);
14314   if (!SWIG_IsOK(ecode4)) {
14315     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'");
14316   } 
14317   arg4 = (PLFLT)(val4);
14318   ecode5 = SWIG_AsVal_double(obj2, &val5);
14319   if (!SWIG_IsOK(ecode5)) {
14320     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'");
14321   } 
14322   arg5 = (PLFLT)(val5);
14323   ecode6 = SWIG_AsVal_double(obj3, &val6);
14324   if (!SWIG_IsOK(ecode6)) {
14325     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'");
14326   } 
14327   arg6 = (PLFLT)(val6);
14328   ecode7 = SWIG_AsVal_double(obj4, &val7);
14329   if (!SWIG_IsOK(ecode7)) {
14330     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'");
14331   } 
14332   arg7 = (PLFLT)(val7);
14333   ecode8 = SWIG_AsVal_double(obj5, &val8);
14334   if (!SWIG_IsOK(ecode8)) {
14335     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'");
14336   } 
14337   arg8 = (PLFLT)(val8);
14338   ecode9 = SWIG_AsVal_double(obj6, &val9);
14339   if (!SWIG_IsOK(ecode9)) {
14340     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'");
14341   } 
14342   arg9 = (PLFLT)(val9);
14343   ecode10 = SWIG_AsVal_double(obj7, &val10);
14344   if (!SWIG_IsOK(ecode10)) {
14345     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'");
14346   } 
14347   arg10 = (PLFLT)(val10);
14348   ecode11 = SWIG_AsVal_double(obj8, &val11);
14349   if (!SWIG_IsOK(ecode11)) {
14350     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'");
14351   } 
14352   arg11 = (PLFLT)(val11);
14353   ecode12 = SWIG_AsVal_double(obj9, &val12);
14354   if (!SWIG_IsOK(ecode12)) {
14355     SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'");
14356   } 
14357   arg12 = (PLFLT)(val12);
14358   ecode13 = SWIG_AsVal_double(obj10, &val13);
14359   if (!SWIG_IsOK(ecode13)) {
14360     SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'");
14361   } 
14362   arg13 = (PLFLT)(val13);
14363   plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14364   resultobj = SWIG_Py_Void();
14365   {
14366     Py_CLEAR( tmp1 );
14367     free( arg1 );
14368   }
14369   return resultobj;
14370 fail:
14371   {
14372     Py_CLEAR( tmp1 );
14373     free( arg1 );
14374   }
14375   return NULL;
14376 }
14377 
14378 
14379 SWIGINTERN PyObject *_wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14380   PyObject *resultobj = 0;
14381   PLFLT **arg1 = (PLFLT **) 0 ;
14382   PLINT arg2 ;
14383   PLINT arg3 ;
14384   PLFLT arg4 ;
14385   PLFLT arg5 ;
14386   PLFLT arg6 ;
14387   PLFLT arg7 ;
14388   PLFLT arg8 ;
14389   PLFLT arg9 ;
14390   PLFLT arg10 ;
14391   PLFLT arg11 ;
14392   pltr_func arg12 = (pltr_func) 0 ;
14393   PLPointer arg13 = (PLPointer) 0 ;
14394   PyArrayObject *tmp1 = NULL ;
14395   double val4 ;
14396   int ecode4 = 0 ;
14397   double val5 ;
14398   int ecode5 = 0 ;
14399   double val6 ;
14400   int ecode6 = 0 ;
14401   double val7 ;
14402   int ecode7 = 0 ;
14403   double val8 ;
14404   int ecode8 = 0 ;
14405   double val9 ;
14406   int ecode9 = 0 ;
14407   double val10 ;
14408   int ecode10 = 0 ;
14409   double val11 ;
14410   int ecode11 = 0 ;
14411   PyObject * obj0 = 0 ;
14412   PyObject * obj1 = 0 ;
14413   PyObject * obj2 = 0 ;
14414   PyObject * obj3 = 0 ;
14415   PyObject * obj4 = 0 ;
14416   PyObject * obj5 = 0 ;
14417   PyObject * obj6 = 0 ;
14418   PyObject * obj7 = 0 ;
14419   PyObject * obj8 = 0 ;
14420   PyObject * obj9 = 0 ;
14421   PyObject * obj10 = 0 ;
14422   
14423   {
14424     python_pltr = 0;
14425     arg12          = NULL;
14426   }
14427   {
14428     arg13 = NULL;
14429   }
14430   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO|OO:plimagefr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
14431   {
14432     int i, size;
14433     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
14434     if ( tmp1 == NULL )
14435     return NULL;
14436     Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14437     Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14438     size = arg3;
14439     arg1   = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14440     for ( i = 0; i < arg2; i++ )
14441     arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14442   }
14443   ecode4 = SWIG_AsVal_double(obj1, &val4);
14444   if (!SWIG_IsOK(ecode4)) {
14445     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
14446   } 
14447   arg4 = (PLFLT)(val4);
14448   ecode5 = SWIG_AsVal_double(obj2, &val5);
14449   if (!SWIG_IsOK(ecode5)) {
14450     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
14451   } 
14452   arg5 = (PLFLT)(val5);
14453   ecode6 = SWIG_AsVal_double(obj3, &val6);
14454   if (!SWIG_IsOK(ecode6)) {
14455     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
14456   } 
14457   arg6 = (PLFLT)(val6);
14458   ecode7 = SWIG_AsVal_double(obj4, &val7);
14459   if (!SWIG_IsOK(ecode7)) {
14460     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
14461   } 
14462   arg7 = (PLFLT)(val7);
14463   ecode8 = SWIG_AsVal_double(obj5, &val8);
14464   if (!SWIG_IsOK(ecode8)) {
14465     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
14466   } 
14467   arg8 = (PLFLT)(val8);
14468   ecode9 = SWIG_AsVal_double(obj6, &val9);
14469   if (!SWIG_IsOK(ecode9)) {
14470     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
14471   } 
14472   arg9 = (PLFLT)(val9);
14473   ecode10 = SWIG_AsVal_double(obj7, &val10);
14474   if (!SWIG_IsOK(ecode10)) {
14475     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
14476   } 
14477   arg10 = (PLFLT)(val10);
14478   ecode11 = SWIG_AsVal_double(obj8, &val11);
14479   if (!SWIG_IsOK(ecode11)) {
14480     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
14481   } 
14482   arg11 = (PLFLT)(val11);
14483   if (obj9) {
14484     {
14485       // it must be a callable or None
14486       if ( obj9 == Py_None )
14487       {
14488         arg12 = NULL;
14489       }
14490       else
14491       {
14492         if ( !PyCallable_Check( (PyObject *) obj9 ) )
14493         {
14494           PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
14495           return NULL;
14496         }
14497         arg12 = marshal_pltr( obj9 );
14498       }
14499     }
14500   }
14501   if (obj10) {
14502     {
14503       if ( obj10 == Py_None )
14504       arg13 = NULL;
14505       else
14506       {
14507         arg13 = marshal_PLPointer( obj10, 1 );
14508       }
14509     }
14510   }
14511   plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14512   resultobj = SWIG_Py_Void();
14513   {
14514     Py_CLEAR( tmp1 );
14515     free( arg1 );
14516   }
14517   {
14518     cleanup_pltr();
14519   }
14520   {
14521     cleanup_PLPointer();
14522   }
14523   return resultobj;
14524 fail:
14525   {
14526     Py_CLEAR( tmp1 );
14527     free( arg1 );
14528   }
14529   {
14530     cleanup_pltr();
14531   }
14532   {
14533     cleanup_PLPointer();
14534   }
14535   return NULL;
14536 }
14537 
14538 
14539 SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14540   PyObject *resultobj = 0;
14541   
14542   if (!PyArg_ParseTuple(args,(char *)":plClearOpts")) SWIG_fail;
14543   plClearOpts();
14544   resultobj = SWIG_Py_Void();
14545   return resultobj;
14546 fail:
14547   return NULL;
14548 }
14549 
14550 
14551 SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14552   PyObject *resultobj = 0;
14553   
14554   if (!PyArg_ParseTuple(args,(char *)":plResetOpts")) SWIG_fail;
14555   plResetOpts();
14556   resultobj = SWIG_Py_Void();
14557   return resultobj;
14558 fail:
14559   return NULL;
14560 }
14561 
14562 
14563 SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14564   PyObject *resultobj = 0;
14565   char *arg1 = (char *) 0 ;
14566   char *arg2 = (char *) 0 ;
14567   int res1 ;
14568   char *buf1 = 0 ;
14569   int alloc1 = 0 ;
14570   int res2 ;
14571   char *buf2 = 0 ;
14572   int alloc2 = 0 ;
14573   PyObject * obj0 = 0 ;
14574   PyObject * obj1 = 0 ;
14575   
14576   if (!PyArg_ParseTuple(args,(char *)"OO:plSetUsage",&obj0,&obj1)) SWIG_fail;
14577   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
14578   if (!SWIG_IsOK(res1)) {
14579     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
14580   }
14581   arg1 = (char *)(buf1);
14582   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14583   if (!SWIG_IsOK(res2)) {
14584     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
14585   }
14586   arg2 = (char *)(buf2);
14587   plSetUsage((char const *)arg1,(char const *)arg2);
14588   resultobj = SWIG_Py_Void();
14589   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
14590   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14591   return resultobj;
14592 fail:
14593   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
14594   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14595   return NULL;
14596 }
14597 
14598 
14599 SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14600   PyObject *resultobj = 0;
14601   
14602   if (!PyArg_ParseTuple(args,(char *)":plOptUsage")) SWIG_fail;
14603   plOptUsage();
14604   resultobj = SWIG_Py_Void();
14605   return resultobj;
14606 fail:
14607   return NULL;
14608 }
14609 
14610 
14611 SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14612   PyObject *resultobj = 0;
14613   PLFLT **arg1 = (PLFLT **) 0 ;
14614   PLINT arg2 ;
14615   PLINT arg3 ;
14616   PLFLT *arg4 = (PLFLT *) 0 ;
14617   PLFLT *arg5 = (PLFLT *) 0 ;
14618   PyArrayObject *tmp1 = NULL ;
14619   PLFLT temp4 ;
14620   int res4 = SWIG_TMPOBJ ;
14621   PLFLT temp5 ;
14622   int res5 = SWIG_TMPOBJ ;
14623   PyObject * obj0 = 0 ;
14624   
14625   arg4 = &temp4;
14626   arg5 = &temp5;
14627   if (!PyArg_ParseTuple(args,(char *)"O:plMinMax2dGrid",&obj0)) SWIG_fail;
14628   {
14629     int i, size;
14630     tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( obj0, NPY_PLFLT, 2, 2 );
14631     if ( tmp1 == NULL )
14632     return NULL;
14633     Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14634     Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14635     size = arg3;
14636     arg1   = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14637     for ( i = 0; i < arg2; i++ )
14638     arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14639   }
14640   plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
14641   resultobj = SWIG_Py_Void();
14642   if (SWIG_IsTmpObj(res4)) {
14643     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
14644   } else {
14645     int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
14646     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
14647   }
14648   if (SWIG_IsTmpObj(res5)) {
14649     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
14650   } else {
14651     int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
14652     resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
14653   }
14654   {
14655     Py_CLEAR( tmp1 );
14656     free( arg1 );
14657   }
14658   return resultobj;
14659 fail:
14660   {
14661     Py_CLEAR( tmp1 );
14662     free( arg1 );
14663   }
14664   return NULL;
14665 }
14666 
14667 
14668 SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14669   PyObject *resultobj = 0;
14670   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14671   void *argp1 = 0 ;
14672   int res1 = 0 ;
14673   PyObject * obj0 = 0 ;
14674   PLINT result;
14675   
14676   if (!PyArg_ParseTuple(args,(char *)"O:plGetCursor",&obj0)) SWIG_fail;
14677   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PLGraphicsIn, 0 |  0 );
14678   if (!SWIG_IsOK(res1)) {
14679     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'"); 
14680   }
14681   arg1 = (PLGraphicsIn *)(argp1);
14682   result = (PLINT)plGetCursor(arg1);
14683   resultobj = SWIG_From_int((int)(result));
14684   return resultobj;
14685 fail:
14686   return NULL;
14687 }
14688 
14689 
14690 static PyMethodDef SwigMethods[] = {
14691          { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
14692          { (char *)"pltr0", _wrap_pltr0, METH_VARARGS, NULL},
14693          { (char *)"pltr1", _wrap_pltr1, METH_VARARGS, NULL},
14694          { (char *)"pltr2", _wrap_pltr2, METH_VARARGS, NULL},
14695          { (char *)"PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL},
14696          { (char *)"PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_VARARGS, NULL},
14697          { (char *)"PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL},
14698          { (char *)"PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_VARARGS, NULL},
14699          { (char *)"PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL},
14700          { (char *)"PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_VARARGS, NULL},
14701          { (char *)"PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL},
14702          { (char *)"PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_VARARGS, NULL},
14703          { (char *)"PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL},
14704          { (char *)"PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_VARARGS, NULL},
14705          { (char *)"PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL},
14706          { (char *)"PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_VARARGS, NULL},
14707          { (char *)"PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL},
14708          { (char *)"PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_VARARGS, NULL},
14709          { (char *)"PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL},
14710          { (char *)"PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_VARARGS, NULL},
14711          { (char *)"PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL},
14712          { (char *)"PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_VARARGS, NULL},
14713          { (char *)"PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL},
14714          { (char *)"PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_VARARGS, NULL},
14715          { (char *)"PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL},
14716          { (char *)"PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_VARARGS, NULL},
14717          { (char *)"PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL},
14718          { (char *)"PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_VARARGS, NULL},
14719          { (char *)"new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_VARARGS, NULL},
14720          { (char *)"delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_VARARGS, NULL},
14721          { (char *)"PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_VARARGS, NULL},
14722          { (char *)"plsxwin", _wrap_plsxwin, METH_VARARGS, NULL},
14723          { (char *)"pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, (char *)"\n"
14724                 "Set format of numerical label for contours\n"
14725                 "\n"
14726                 "DESCRIPTION:\n"
14727                 "\n"
14728                 "    Set format of numerical label for contours. \n"
14729                 "\n"
14730                 "    Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
14731                 "\n"
14732                 "    This function is used example 9. \n"
14733                 "\n"
14734                 "\n"
14735                 "\n"
14736                 "SYNOPSIS:\n"
14737                 "\n"
14738                 "pl_setcontlabelformat(lexp, sigdig)\n"
14739                 "\n"
14740                 "ARGUMENTS:\n"
14741                 "\n"
14742                 "    lexp (PLINT, input) :    If the contour numerical label is greater\n"
14743                 "    than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
14744                 "    format is used.  Default value of lexp is 4. \n"
14745                 "\n"
14746                 "    sigdig (PLINT, input) :    Number of significant digits.  Default\n"
14747                 "    value is 2. \n"
14748                 "\n"
14749                 ""},
14750          { (char *)"pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, (char *)"\n"
14751                 "Set parameters of contour labelling other than format of numerical label\n"
14752                 "\n"
14753                 "DESCRIPTION:\n"
14754                 "\n"
14755                 "    Set parameters of contour labelling other than those handled by\n"
14756                 "    pl_setcontlabelformat. \n"
14757                 "\n"
14758                 "    Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
14759                 "\n"
14760                 "    This function is used in example 9. \n"
14761                 "\n"
14762                 "\n"
14763                 "\n"
14764                 "SYNOPSIS:\n"
14765                 "\n"
14766                 "pl_setcontlabelparam(offset, size, spacing, active)\n"
14767                 "\n"
14768                 "ARGUMENTS:\n"
14769                 "\n"
14770                 "    offset (PLFLT, input) :    Offset of label from contour line (if set\n"
14771                 "    to 0.0, labels are printed on the lines).  Default value is 0.006. \n"
14772                 "\n"
14773                 "    size (PLFLT, input) :    Font height for contour labels (normalized). \n"
14774                 "    Default value is 0.3. \n"
14775                 "\n"
14776                 "    spacing (PLFLT, input) :    Spacing parameter for contour labels. \n"
14777                 "    Default value is 0.1. \n"
14778                 "\n"
14779                 "    active (PLINT, input) :    Activate labels.  Set to 1 if you want\n"
14780                 "    contour labels on. Default is off (0). \n"
14781                 "\n"
14782                 ""},
14783          { (char *)"pladv", _wrap_pladv, METH_VARARGS, (char *)"\n"
14784                 "Advance the (sub-)page\n"
14785                 "\n"
14786                 "DESCRIPTION:\n"
14787                 "\n"
14788                 "    Advances to the next subpage if sub=0, performing a page advance if\n"
14789                 "    there are no remaining subpages on the current page.  If subpages\n"
14790                 "    aren't being used, pladv(0) will always advance the page.  If page>0,\n"
14791                 "    PLplot switches to the specified subpage.  Note that this allows you\n"
14792                 "    to overwrite a plot on the specified subpage; if this is not what you\n"
14793                 "    intended, use pleop followed by plbop to first advance the page.  This\n"
14794                 "    routine is called automatically (with page=0) by plenv, but if plenv\n"
14795                 "    is not used, pladv must be called after initializing PLplot but before\n"
14796                 "    defining the viewport. \n"
14797                 "\n"
14798                 "    Redacted form: pladv(page)\n"
14799                 "\n"
14800                 "    This function is used in examples 1,2,4,6-12,14-18,20,21,23-27,29,31. \n"
14801                 "\n"
14802                 "\n"
14803                 "\n"
14804                 "SYNOPSIS:\n"
14805                 "\n"
14806                 "pladv(page)\n"
14807                 "\n"
14808                 "ARGUMENTS:\n"
14809                 "\n"
14810                 "    page (PLINT, input) :    Specifies the subpage number (starting from 1\n"
14811                 "    in the top left corner and increasing along the rows) to which to\n"
14812                 "    advance.  Set to zero to advance to the next subpage (or to the\n"
14813                 "    next page if subpages are not being used). \n"
14814                 "\n"
14815                 ""},
14816          { (char *)"plarc", _wrap_plarc, METH_VARARGS, (char *)"\n"
14817                 "Draw a circular or elliptical arc \n"
14818                 "\n"
14819                 "DESCRIPTION:\n"
14820                 "\n"
14821                 "    Draw a possibly filled arc centered at x, y with semimajor axis  a and\n"
14822                 "    semiminor axis  b, starting at  angle1 and ending at  angle2. \n"
14823                 "\n"
14824                 "    Redacted form:  General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
14825                 "    fill)\n"
14826                 "\n"
14827                 "\n"
14828                 "    This function is used in examples 3 and 27. \n"
14829                 "\n"
14830                 "\n"
14831                 "\n"
14832                 "SYNOPSIS:\n"
14833                 "\n"
14834                 "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
14835                 "\n"
14836                 "ARGUMENTS:\n"
14837                 "\n"
14838                 "    x (PLFLT, input) :      X coordinate of arc center. \n"
14839                 "\n"
14840                 "    y (PLFLT, input) :      Y coordinate of arc center. \n"
14841                 "\n"
14842                 "    a (PLFLT, input) :      Length of the semimajor axis of the arc. \n"
14843                 "\n"
14844                 "    b (PLFLT, input) :      Length of the semiminor axis of the arc. \n"
14845                 "\n"
14846                 "    angle1 (PLFLT, input) :    Starting angle of the arc relative to the\n"
14847                 "    semimajor axis. \n"
14848                 "\n"
14849                 "    angle2 (PLFLT, input) :    Ending angle of the arc relative to the\n"
14850                 "    semimajor axis. \n"
14851                 "\n"
14852                 "    rotate (PLFLT, input) :    Angle of the semimajor axis relative to the\n"
14853                 "    X-axis. \n"
14854                 "\n"
14855                 "    fill (PLBOOL, input) :    Draw a filled arc. \n"
14856                 "\n"
14857                 ""},
14858          { (char *)"plaxes", _wrap_plaxes, METH_VARARGS, (char *)"\n"
14859                 "Draw a box with axes, etc. with arbitrary origin \n"
14860                 "\n"
14861                 "DESCRIPTION:\n"
14862                 "\n"
14863                 "    Draws a box around the currently defined viewport with arbitrary\n"
14864                 "    world-coordinate origin specified by x0 and y0 and labels it with\n"
14865                 "    world coordinate values appropriate to the window. Thus plaxes should\n"
14866                 "    only be called after defining both viewport and window.  The character\n"
14867                 "    strings xopt and yopt specify how the box should be drawn as described\n"
14868                 "    below.  If ticks and/or subticks are to be drawn for a particular\n"
14869                 "    axis, the tick intervals and number of subintervals may be specified\n"
14870                 "    explicitly, or they may be defaulted by setting the appropriate\n"
14871                 "    arguments to zero. \n"
14872                 "\n"
14873                 "    Redacted form:  General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
14874                 "    ytick, nysub)\n"
14875                 "           Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n"
14876                 "    yopt)\n"
14877                 "\n"
14878                 "\n"
14879                 "    This function is not used in any examples. \n"
14880                 "\n"
14881                 "\n"
14882                 "\n"
14883                 "SYNOPSIS:\n"
14884                 "\n"
14885                 "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14886                 "\n"
14887                 "ARGUMENTS:\n"
14888                 "\n"
14889                 "    x0 (PLFLT, input) :    World X coordinate of origin. \n"
14890                 "\n"
14891                 "    y0 (PLFLT, input) :    World Y coordinate of origin. \n"
14892                 "\n"
14893                 "    xopt (const char *, input) :    Pointer to character string specifying\n"
14894                 "    options for horizontal axis.  The string can include any\n"
14895                 "    combination of the following letters (upper or lower case) in any\n"
14896                 "    order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n"
14897                 "    is vertical line (x=0). \n"
14898                 "        b: Draws bottom (X) or left (Y) edge of frame. \n"
14899                 "        c: Draws top (X) or right (Y) edge of frame. \n"
14900                 "        d: Plot labels as date / time.  Values are assumed to be\n"
14901                 "        seconds since the epoch  (as used by gmtime). \n"
14902                 "        f:    Always use fixed point numeric labels. \n"
14903                 "        g: Draws a grid at the major tick interval. \n"
14904                 "        h: Draws a grid at the minor tick interval. \n"
14905                 "        i: Inverts tick marks, so they are drawn outwards, rather than\n"
14906                 "        inwards. \n"
14907                 "        l: Labels axis logarithmically.  This only affects the labels,\n"
14908                 "        not the data, and so it is necessary to compute the logarithms\n"
14909                 "        of data points before passing them to any of the drawing\n"
14910                 "        routines. \n"
14911                 "        m: Writes numeric labels at major tick intervals in the\n"
14912                 "        unconventional location (above box for X, right of box for Y). \n"
14913                 "        n: Writes numeric labels at major tick intervals in the\n"
14914                 "        conventional location (below box for X, left of box for Y). \n"
14915                 "        o: Use custom labelling function to generate axis label text. \n"
14916                 "        The custom labelling function can be defined with the\n"
14917                 "        plslabelfunc command. \n"
14918                 "        s: Enables subticks between major ticks, only valid if t is\n"
14919                 "        also specified. \n"
14920                 "        t: Draws major ticks. \n"
14921                 "        u: Exactly like \"b\" except don't draw edge line. \n"
14922                 "        w: Exactly like \"c\" except don't draw edge line. \n"
14923                 "        x: Exactly like \"t\" (including the side effect of the\n"
14924                 "        numerical labels for the major ticks) except exclude drawing\n"
14925                 "        the major and minor tick marks. \n"
14926                 "\n"
14927                 "\n"
14928                 "    xtick (PLFLT, input) :    World coordinate interval between major\n"
14929                 "    ticks on the x axis. If it is set to zero, PLplot automatically\n"
14930                 "    generates a suitable tick interval. \n"
14931                 "\n"
14932                 "    nxsub (PLINT, input) :    Number of subintervals between major x axis\n"
14933                 "    ticks for minor ticks.    If it is set to zero, PLplot automatically\n"
14934                 "    generates a suitable minor tick interval. \n"
14935                 "\n"
14936                 "    yopt (const char *, input) :    Pointer to character string specifying\n"
14937                 "    options for vertical axis.  The string can include any combination\n"
14938                 "    of the letters defined above for xopt, and in addition may\n"
14939                 "    contain: v: Write numeric labels for vertical axis parallel to the\n"
14940                 "    base of the graph, rather than parallel to the axis. \n"
14941                 "\n"
14942                 "\n"
14943                 "    ytick (PLFLT, input) :    World coordinate interval between major\n"
14944                 "    ticks on the y axis. If it is set to zero, PLplot automatically\n"
14945                 "    generates a suitable tick interval. \n"
14946                 "\n"
14947                 "    nysub (PLINT, input) :    Number of subintervals between major y axis\n"
14948                 "    ticks for minor ticks.    If it is set to zero, PLplot automatically\n"
14949                 "    generates a suitable minor tick interval. \n"
14950                 "\n"
14951                 ""},
14952          { (char *)"plbin", _wrap_plbin, METH_VARARGS, (char *)"\n"
14953                 "Plot a histogram from binned data \n"
14954                 "\n"
14955                 "DESCRIPTION:\n"
14956                 "\n"
14957                 "    Plots a histogram consisting of nbin bins. The value associated with\n"
14958                 "    the i'th bin is placed in x[i], and the number of points in the bin is\n"
14959                 "    placed in y[i].  For proper operation, the values in x[i] must form a\n"
14960                 "    strictly increasing sequence.  By default, x[i] is the left-hand edge\n"
14961                 "    of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
14962                 "    placed midway between the values in the x array.  Also see plhist for\n"
14963                 "    drawing histograms from unbinned data. \n"
14964                 "\n"
14965                 "    Redacted form:  General: plbin(x, y, opt)\n"
14966                 "           Perl/PDL: plbin(nbin, x, y, opt)\n"
14967                 "           Python: plbin(nbin, x, y, opt)\n"
14968                 "\n"
14969                 "\n"
14970                 "    This function is not used in any examples. \n"
14971                 "\n"
14972                 "\n"
14973                 "\n"
14974                 "SYNOPSIS:\n"
14975                 "\n"
14976                 "plbin(nbin, x, y, opt)\n"
14977                 "\n"
14978                 "ARGUMENTS:\n"
14979                 "\n"
14980                 "    nbin (PLINT, input) :    Number of bins (i.e., number of values in x\n"
14981                 "    and y arrays.) \n"
14982                 "\n"
14983                 "    x (const PLFLT *, input) :      Pointer to array containing values\n"
14984                 "    associated with bins.  These must form a strictly increasing\n"
14985                 "    sequence. \n"
14986                 "\n"
14987                 "    y (const PLFLT *, input) :      Pointer to array containing number of\n"
14988                 "    points in bin.    This is a PLFLT (instead of PLINT) array so as to\n"
14989                 "    allow histograms of probabilities, etc. \n"
14990                 "\n"
14991                 "    opt (PLINT, input) :    Is a combination of several flags:\n"
14992                 "    opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
14993                 "    outer bins are expanded to fill up the entire x-axis and bins of\n"
14994                 "    zero height are simply drawn. \n"
14995                 "        opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
14996                 "        between the x values. If the values in x are equally spaced,\n"
14997                 "        the values are the center values of the bins. \n"
14998                 "        opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
14999                 "        size as the ones inside. \n"
15000                 "        opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
15001                 "        (there is a gap for such bins). \n"
15002                 "\n"
15003                 ""},
15004          { (char *)"plbtime", _wrap_plbtime, METH_VARARGS, (char *)"\n"
15005                 "Calculate broken-down time from continuous time for the current stream \n"
15006                 "\n"
15007                 "DESCRIPTION:\n"
15008                 "\n"
15009                 "    Calculate broken-down time;  year, month, day, hour, min, sec; from\n"
15010                 "    continuous time, ctime for the current stream.  This function is the\n"
15011                 "    inverse of plctime. \n"
15012                 "\n"
15013                 "    The PLplot definition of broken-down time is a calendar time that\n"
15014                 "    completely ignores all time zone offsets, i.e., it is the user's\n"
15015                 "    responsibility to apply those offsets (if so desired) before using the\n"
15016                 "    PLplot time API.  By default broken-down time is defined using the\n"
15017                 "    proleptic Gregorian calendar without the insertion of leap seconds and\n"
15018                 "    continuous time is defined as the number of seconds since the Unix\n"
15019                 "    epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
15020                 "    broken-down and continuous time are possible, see plconfigtime. \n"
15021                 "\n"
15022                 "    Redacted form:  General: plbtime(year, month, day, hour, min, sec,\n"
15023                 "    ctime)\n"
15024                 "           Perl/PDL: Not available? \n"
15025                 "\n"
15026                 "\n"
15027                 "    This function is used in example 29. \n"
15028                 "\n"
15029                 "\n"
15030                 "\n"
15031                 "SYNOPSIS:\n"
15032                 "\n"
15033                 "plbtime(year, month, day, hour, min, sec, ctime)\n"
15034                 "\n"
15035                 "ARGUMENTS:\n"
15036                 "\n"
15037                 "    year (PLINT *, output) :    Output year. \n"
15038                 "\n"
15039                 "    month (PLINT *, output) :     Output month in range from 0 (January) to\n"
15040                 "    11 (December). \n"
15041                 "\n"
15042                 "    day (PLINT *, output) :    Output day in range from 1 to 31. \n"
15043                 "\n"
15044                 "    hour (PLINT *, output) :    Output hour in range from 0 to 23. \n"
15045                 "\n"
15046                 "    min (PLINT *, output) :    Output minute in range from 0 to 59 \n"
15047                 "\n"
15048                 "    sec (PLFLT *, output) :    Output second in floating range from 0. to\n"
15049                 "    60. \n"
15050                 "\n"
15051                 "    ctime (PLFLT, input) :    Continous time from which the broken-down\n"
15052                 "    time is calculated. \n"
15053                 "\n"
15054                 ""},
15055          { (char *)"plbop", _wrap_plbop, METH_VARARGS, (char *)"\n"
15056                 "Begin a new page\n"
15057                 "\n"
15058                 "DESCRIPTION:\n"
15059                 "\n"
15060                 "    Begins a new page. For a file driver, the output file is opened if\n"
15061                 "    necessary. Advancing the page via pleop and plbop is useful when a\n"
15062                 "    page break is desired at a particular point when plotting to subpages.\n"
15063                 "     Another use for pleop and plbop is when plotting pages to different\n"
15064                 "    files, since you can manually set the file name by calling plsfnam\n"
15065                 "    after the call to pleop. (In fact some drivers may only support a\n"
15066                 "    single page per file, making this a necessity.)  One way to handle\n"
15067                 "    this case automatically is to page advance via pladv, but enable\n"
15068                 "    familying (see plsfam) with a small limit on the file size so that a\n"
15069                 "    new family member file will be created on each page break. \n"
15070                 "\n"
15071                 "    Redacted form: plbop()\n"
15072                 "\n"
15073                 "    This function is used in examples 2,20. \n"
15074                 "\n"
15075                 "\n"
15076                 "\n"
15077                 "SYNOPSIS:\n"
15078                 "\n"
15079                 "plbop()\n"
15080                 "\n"
15081                 ""},
15082          { (char *)"plbox", _wrap_plbox, METH_VARARGS, (char *)"\n"
15083                 "Draw a box with axes, etc\n"
15084                 "\n"
15085                 "DESCRIPTION:\n"
15086                 "\n"
15087                 "    Draws a box around the currently defined viewport, and labels it with\n"
15088                 "    world coordinate values appropriate to the window. Thus plbox should\n"
15089                 "    only be called after defining both viewport and window.  The character\n"
15090                 "    strings xopt and yopt specify how the box should be drawn as described\n"
15091                 "    below.  If ticks and/or subticks are to be drawn for a particular\n"
15092                 "    axis, the tick intervals and number of subintervals may be specified\n"
15093                 "    explicitly, or they may be defaulted by setting the appropriate\n"
15094                 "    arguments to zero. \n"
15095                 "\n"
15096                 "    Redacted form:  General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15097                 "           Perl/PDL: plbox(xtick, nxsub, ytick, nysub, xopt, yopt)\n"
15098                 "\n"
15099                 "\n"
15100                 "    This function is used in examples 1,2,4,6,6-12,14-18,21,23-26,29. \n"
15101                 "\n"
15102                 "\n"
15103                 "\n"
15104                 "SYNOPSIS:\n"
15105                 "\n"
15106                 "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15107                 "\n"
15108                 "ARGUMENTS:\n"
15109                 "\n"
15110                 "    xopt (const char *, input) :    Pointer to character string specifying\n"
15111                 "    options for horizontal axis.  The string can include any\n"
15112                 "    combination of the following letters (upper or lower case) in any\n"
15113                 "    order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n"
15114                 "    is vertical line (x=0). \n"
15115                 "        b: Draws bottom (X) or left (Y) edge of frame. \n"
15116                 "        c: Draws top (X) or right (Y) edge of frame. \n"
15117                 "        d: Plot labels as date / time.  Values are assumed to be\n"
15118                 "        seconds since the epoch  (as used by gmtime). \n"
15119                 "        f:    Always use fixed point numeric labels. \n"
15120                 "        g: Draws a grid at the major tick interval. \n"
15121                 "        h: Draws a grid at the minor tick interval. \n"
15122                 "        i: Inverts tick marks, so they are drawn outwards, rather than\n"
15123                 "        inwards. \n"
15124                 "        l: Labels axis logarithmically.  This only affects the labels,\n"
15125                 "        not the data, and so it is necessary to compute the logarithms\n"
15126                 "        of data points before passing them to any of the drawing\n"
15127                 "        routines. \n"
15128                 "        m: Writes numeric labels at major tick intervals in the\n"
15129                 "        unconventional location (above box for X, right of box for Y). \n"
15130                 "        n: Writes numeric labels at major tick intervals in the\n"
15131                 "        conventional location (below box for X, left of box for Y). \n"
15132                 "        o: Use custom labelling function to generate axis label text. \n"
15133                 "        The custom labelling function can be defined with the\n"
15134                 "        plslabelfunc command. \n"
15135                 "        s: Enables subticks between major ticks, only valid if t is\n"
15136                 "        also specified. \n"
15137                 "        t: Draws major ticks. \n"
15138                 "        u: Exactly like \"b\" except don't draw edge line. \n"
15139                 "        w: Exactly like \"c\" except don't draw edge line. \n"
15140                 "        x: Exactly like \"t\" (including the side effect of the\n"
15141                 "        numerical labels for the major ticks) except exclude drawing\n"
15142                 "        the major and minor tick marks. \n"
15143                 "\n"
15144                 "\n"
15145                 "    xtick (PLFLT, input) :    World coordinate interval between major\n"
15146                 "    ticks on the x axis. If it is set to zero, PLplot automatically\n"
15147                 "    generates a suitable tick interval. \n"
15148                 "\n"
15149                 "    nxsub (PLINT, input) :    Number of subintervals between major x axis\n"
15150                 "    ticks for minor ticks.    If it is set to zero, PLplot automatically\n"
15151                 "    generates a suitable minor tick interval. \n"
15152                 "\n"
15153                 "    yopt (const char *, input) :    Pointer to character string specifying\n"
15154                 "    options for vertical axis.  The string can include any combination\n"
15155                 "    of the letters defined above for xopt, and in addition may\n"
15156                 "    contain: v: Write numeric labels for vertical axis parallel to the\n"
15157                 "    base of the graph, rather than parallel to the axis. \n"
15158                 "\n"
15159                 "\n"
15160                 "    ytick (PLFLT, input) :    World coordinate interval between major\n"
15161                 "    ticks on the y axis. If it is set to zero, PLplot automatically\n"
15162                 "    generates a suitable tick interval. \n"
15163                 "\n"
15164                 "    nysub (PLINT, input) :    Number of subintervals between major y axis\n"
15165                 "    ticks for minor ticks.    If it is set to zero, PLplot automatically\n"
15166                 "    generates a suitable minor tick interval. \n"
15167                 "\n"
15168                 ""},
15169          { (char *)"plbox3", _wrap_plbox3, METH_VARARGS, (char *)"\n"
15170                 "Draw a box with axes, etc, in 3-d \n"
15171                 "\n"
15172                 "DESCRIPTION:\n"
15173                 "\n"
15174                 "    Draws axes, numeric and text labels for a three-dimensional surface\n"
15175                 "    plot.  For a more complete description of three-dimensional plotting\n"
15176                 "    see the PLplot documentation. \n"
15177                 "\n"
15178                 "    Redacted form:  General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15179                 "    ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15180                 "           Perl/PDL: plbox3(xtick, nxsub, ytick, nysub, ztick, nzsub,\n"
15181                 "    xopt, xlabel, yopt, ylabel, zopt, zlabel)\n"
15182                 "\n"
15183                 "\n"
15184                 "    This function is used in examples 8,11,18,21. \n"
15185                 "\n"
15186                 "\n"
15187                 "\n"
15188                 "SYNOPSIS:\n"
15189                 "\n"
15190                 "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15191                 "\n"
15192                 "ARGUMENTS:\n"
15193                 "\n"
15194                 "    xopt (const char *, input) :    Pointer to character string specifying\n"
15195                 "    options for the x axis. The string can include any combination of\n"
15196                 "    the following letters (upper or lower case) in any order: b: Draws\n"
15197                 "    axis at base, at height z=\n"
15198                 "    zmin where zmin is defined by call to plw3d.  This character must be\n"
15199                 "    specified in order to use any of the other options. \n"
15200                 "        f: Always use fixed point numeric labels. \n"
15201                 "        i: Inverts tick marks, so they are drawn downwards, rather\n"
15202                 "        than upwards. \n"
15203                 "        l: Labels axis logarithmically.  This only affects the labels,\n"
15204                 "        not the data, and so it is necessary to compute the logarithms\n"
15205                 "        of data points before passing them to any of the drawing\n"
15206                 "        routines. \n"
15207                 "        n: Writes numeric labels at major tick intervals. \n"
15208                 "        o: Use custom labelling function to generate axis label text. \n"
15209                 "        The custom labelling function can be defined with the\n"
15210                 "        plslabelfunc command. \n"
15211                 "        s: Enables subticks between major ticks, only valid if t is\n"
15212                 "        also specified. \n"
15213                 "        t: Draws major ticks. \n"
15214                 "        u: If this is specified, the text label for the axis is\n"
15215                 "        written under the axis. \n"
15216                 "\n"
15217                 "\n"
15218                 "    xlabel (const char *, input) :    Pointer to character string\n"
15219                 "    specifying text label for the x axis.  It is only drawn if u is in\n"
15220                 "    the xopt string. \n"
15221                 "\n"
15222                 "    xtick (PLFLT, input) :    World coordinate interval between major\n"
15223                 "    ticks on the x axis. If it is set to zero, PLplot automatically\n"
15224                 "    generates a suitable tick interval. \n"
15225                 "\n"
15226                 "    nxsub (PLINT, input) :    Number of subintervals between major x axis\n"
15227                 "    ticks for minor ticks.    If it is set to zero, PLplot automatically\n"
15228                 "    generates a suitable minor tick interval. \n"
15229                 "\n"
15230                 "    yopt (const char *, input) :    Pointer to character string specifying\n"
15231                 "    options for the y axis. The string is interpreted in the same way\n"
15232                 "    as xopt. \n"
15233                 "\n"
15234                 "    ylabel (const char *, input) :    Pointer to character string\n"
15235                 "    specifying text label for the y axis.  It is only drawn if u is in\n"
15236                 "    the yopt string. \n"
15237                 "\n"
15238                 "    ytick (PLFLT, input) :    World coordinate interval between major\n"
15239                 "    ticks on the y axis. If it is set to zero, PLplot automatically\n"
15240                 "    generates a suitable tick interval. \n"
15241                 "\n"
15242                 "    nysub (PLINT, input) :    Number of subintervals between major y axis\n"
15243                 "    ticks for minor ticks.    If it is set to zero, PLplot automatically\n"
15244                 "    generates a suitable minor tick interval. \n"
15245                 "\n"
15246                 "    zopt (const char *, input) :    Pointer to character string specifying\n"
15247                 "    options for the z axis. The string can include any combination of\n"
15248                 "    the following letters (upper or lower case) in any order: b: Draws\n"
15249                 "    z axis to the left of the surface plot. \n"
15250                 "        c: Draws z axis to the right of the surface plot. \n"
15251                 "        d: Draws grid lines parallel to the x-y plane behind the\n"
15252                 "        figure.  These lines are not drawn until after plot3d or\n"
15253                 "        plmesh are called because of the need for hidden line removal. \n"
15254                 "        f: Always use fixed point numeric labels. \n"
15255                 "        i: Inverts tick marks, so they are drawn away from the center. \n"
15256                 "        l: Labels axis logarithmically.  This only affects the labels,\n"
15257                 "        not the data, and so it is necessary to compute the logarithms\n"
15258                 "        of data points before passing them to any of the drawing\n"
15259                 "        routines. \n"
15260                 "        m: Writes numeric labels at major tick intervals on the\n"
15261                 "        right-hand vertical axis. \n"
15262                 "        n: Writes numeric labels at major tick intervals on the\n"
15263                 "        left-hand vertical axis. \n"
15264                 "        o: Use custom labelling function to generate axis label text. \n"
15265                 "        The custom labelling function can be defined with the\n"
15266                 "        plslabelfunc command. \n"
15267                 "        s: Enables subticks between major ticks, only valid if t is\n"
15268                 "        also specified. \n"
15269                 "        t: Draws major ticks. \n"
15270                 "        u: If this is specified, the text label is written beside the\n"
15271                 "        left-hand axis. \n"
15272                 "        v: If this is specified, the text label is written beside the\n"
15273                 "        right-hand axis. \n"
15274                 "\n"
15275                 "\n"
15276                 "    zlabel (const char *, input) :    Pointer to character string\n"
15277                 "    specifying text label for the z axis.  It is only drawn if u or v\n"
15278                 "    are in the zopt string. \n"
15279                 "\n"
15280                 "    ztick (PLFLT, input) :    World coordinate interval between major\n"
15281                 "    ticks on the z axis. If it is set to zero, PLplot automatically\n"
15282                 "    generates a suitable tick interval. \n"
15283                 "\n"
15284                 "    nzsub (PLINT, input) :    Number of subintervals between major z axis\n"
15285                 "    ticks for minor ticks.    If it is set to zero, PLplot automatically\n"
15286                 "    generates a suitable minor tick interval. \n"
15287                 "\n"
15288                 ""},
15289          { (char *)"plcalc_world", _wrap_plcalc_world, METH_VARARGS, (char *)"\n"
15290                 "Calculate world coordinates and corresponding window index from relative device coordinates \n"
15291                 "\n"
15292                 "DESCRIPTION:\n"
15293                 "\n"
15294                 "    Calculate world coordinates, wx and wy, and corresponding window index\n"
15295                 "    from relative device coordinates, rx and ry. \n"
15296                 "\n"
15297                 "    Redacted form:  General: plcalc_world(rx, ry, wx, wy, window)\n"
15298                 "           Perl/PDL: Not available? \n"
15299                 "\n"
15300                 "\n"
15301                 "    This function is used in example 31. \n"
15302                 "\n"
15303                 "\n"
15304                 "\n"
15305                 "SYNOPSIS:\n"
15306                 "\n"
15307                 "plcalc_world(rx, ry, wx, wy, window)\n"
15308                 "\n"
15309                 "ARGUMENTS:\n"
15310                 "\n"
15311                 "    rx (PLFLT, input) :    Input relative device coordinate (ranging from\n"
15312                 "    0. to 1.) for the x coordinate. \n"
15313                 "\n"
15314                 "    ry (PLFLT, input) :    Input relative device coordinate (ranging from\n"
15315                 "    0. to 1.) for the y coordinate. \n"
15316                 "\n"
15317                 "    wx (PLFLT *, output) :    Pointer to the returned world coordinate for\n"
15318                 "    x corresponding to the relative device coordinates rx and ry. \n"
15319                 "\n"
15320                 "    wy (PLFLT *, output) :    Pointer to the returned world coordinate for\n"
15321                 "    y corresponding to the relative device coordinates rx and ry. \n"
15322                 "\n"
15323                 "    window (PLINT *, output) :      Pointer to the returned last defined\n"
15324                 "    window index that corresponds to the input relative device\n"
15325                 "    coordinates (and the returned world coordinates).  To give some\n"
15326                 "    background on the window index, for each page the initial window\n"
15327                 "    index is set to zero, and each time plwind is called within the\n"
15328                 "    page, world and device coordinates are stored for the window and\n"
15329                 "    the window index is incremented.  Thus, for a simple page layout\n"
15330                 "    with non-overlapping viewports and one window per viewport, window\n"
15331                 "    corresponds to the viewport index (in the order which the\n"
15332                 "    viewport/windows were created) of the only viewport/window\n"
15333                 "    corresponding to rx and ry.  However, for more complicated layouts\n"
15334                 "    with potentially overlapping viewports and possibly more than one\n"
15335                 "    window (set of world coordinates) per viewport, window and the\n"
15336                 "    corresponding output world coordinates corresponds to the last\n"
15337                 "    window created that fulfills the criterion that the relative\n"
15338                 "    device coordinates are inside it.  Finally, in all cases where the\n"
15339                 "    input relative device coordinates are not inside any\n"
15340                 "    viewport/window, then window is set to -1. \n"
15341                 "\n"
15342                 ""},
15343          { (char *)"plclear", _wrap_plclear, METH_VARARGS, (char *)"\n"
15344                 "Clear current (sub)page \n"
15345                 "\n"
15346                 "DESCRIPTION:\n"
15347                 "\n"
15348                 "    Clears the current page, effectively erasing everything that have been\n"
15349                 "    drawn.  This command only works with interactive drivers; if the\n"
15350                 "    driver does not support this, the page is filled with the background\n"
15351                 "    color in use. If the current page is divided into subpages, only the\n"
15352                 "    current subpage is erased. The nth subpage can be selected with\n"
15353                 "    pladv(n). \n"
15354                 "\n"
15355                 "    Redacted form:  General: plclear()\n"
15356                 "           Perl/PDL: Not available? \n"
15357                 "\n"
15358                 "\n"
15359                 "    This function is not used in any examples. \n"
15360                 "\n"
15361                 "\n"
15362                 "\n"
15363                 "SYNOPSIS:\n"
15364                 "\n"
15365                 "plclear()\n"
15366                 "\n"
15367                 ""},
15368          { (char *)"plcol0", _wrap_plcol0, METH_VARARGS, (char *)"\n"
15369                 "Set color, cmap0 \n"
15370                 "\n"
15371                 "DESCRIPTION:\n"
15372                 "\n"
15373                 "    Sets the color index for cmap0 (see the PLplot documentation). \n"
15374                 "\n"
15375                 "    Redacted form: plcol0(icol0)\n"
15376                 "\n"
15377                 "    This function is used in examples 1-9,11-16,18-27,29. \n"
15378                 "\n"
15379                 "\n"
15380                 "\n"
15381                 "SYNOPSIS:\n"
15382                 "\n"
15383                 "plcol0(icol0)\n"
15384                 "\n"
15385                 "ARGUMENTS:\n"
15386                 "\n"
15387                 "    icol0 (PLINT, input) :    Integer representing the color.  The\n"
15388                 "    defaults at present are (these may change): \n"
15389                 "    0       black (default background) \n"
15390                 "    1       red (default foreground) \n"
15391                 "    2       yellow \n"
15392                 "    3       green \n"
15393                 "    4       aquamarine \n"
15394                 "    5       pink \n"
15395                 "    6       wheat \n"
15396                 "    7       grey \n"
15397                 "    8       brown \n"
15398                 "    9       blue \n"
15399                 "    10        BlueViolet \n"
15400                 "    11        cyan \n"
15401                 "    12        turquoise \n"
15402                 "    13        magenta \n"
15403                 "    14        salmon \n"
15404                 "    15        white \n"
15405                 "\n"
15406                 "      Use plscmap0 to change the entire map0 color palette and plscol0 to\n"
15407                 "     change an individual color in the map0 color palette. \n"
15408                 "\n"
15409                 ""},
15410          { (char *)"plcol1", _wrap_plcol1, METH_VARARGS, (char *)"\n"
15411                 "Set color, cmap1 \n"
15412                 "\n"
15413                 "DESCRIPTION:\n"
15414                 "\n"
15415                 "    Sets the color for cmap1 (see the PLplot documentation).  \n"
15416                 "\n"
15417                 "    Redacted form: plcol1(col1)\n"
15418                 "\n"
15419                 "    This function is used in examples 12 and 21. \n"
15420                 "\n"
15421                 "\n"
15422                 "\n"
15423                 "SYNOPSIS:\n"
15424                 "\n"
15425                 "plcol1(col1)\n"
15426                 "\n"
15427                 "ARGUMENTS:\n"
15428                 "\n"
15429                 "    col1 (PLFLT, input) :    This value must be in the range from 0. to 1.\n"
15430                 "    and is mapped to color using the continuous map1 color palette\n"
15431                 "    which by default ranges from blue to the background color to red. \n"
15432                 "    The map1 palette can also be straightforwardly changed by the user\n"
15433                 "    with plscmap1 or plscmap1l. \n"
15434                 "\n"
15435                 ""},
15436          { (char *)"plconfigtime", _wrap_plconfigtime, METH_VARARGS, (char *)"\n"
15437                 "Configure the transformation between continuous and broken-down time for the current stream \n"
15438                 "\n"
15439                 "DESCRIPTION:\n"
15440                 "\n"
15441                 "    Configure the transformation between continuous and broken-down time\n"
15442                 "    for the current stream.  This transformation is used by both plbtime\n"
15443                 "    and plctime. \n"
15444                 "\n"
15445                 "    Redacted form:  General: plconfigtime(scale, offset1, offset2,\n"
15446                 "    ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
15447                 "           Perl/PDL: Not available? \n"
15448                 "\n"
15449                 "\n"
15450                 "    This function is used in example 29. \n"
15451                 "\n"
15452                 "\n"
15453                 "\n"
15454                 "SYNOPSIS:\n"
15455                 "\n"
15456                 "plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
15457                 "\n"
15458                 "ARGUMENTS:\n"
15459                 "\n"
15460                 "    scale (PLFLT, input) :    The number of days per continuous time unit.\n"
15461                 "     As a special case, if \n"
15462                 "    scale is 0., then all other arguments are ignored, and the result (the\n"
15463                 "    default used by PLplot) is the equivalent of a call to\n"
15464                 "    plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n"
15465                 "    That is, for this special case broken-down time is calculated with\n"
15466                 "    the proleptic Gregorian calendar with no leap seconds inserted,\n"
15467                 "    and the continuous time is defined as the number of seconds since\n"
15468                 "    the Unix epoch of  1970-01-01T00:00:00Z. \n"
15469                 "\n"
15470                 "    offset1 (PLFLT, input) :    If \n"
15471                 "    ifbtime_offset is true, the parameters \n"
15472                 "    offset1 and \n"
15473                 "    offset2 are completely ignored. Otherwise, the sum of these parameters\n"
15474                 "    (with units in days) specify the epoch of the continuous time\n"
15475                 "    relative to the MJD epoch corresponding to the Gregorian calendar\n"
15476                 "    date of 1858-11-17T00:00:00Z or JD = 2400000.5.  Two PLFLT numbers\n"
15477                 "    are used to specify the origin to allow users (by specifying \n"
15478                 "    offset1 as an integer that can be exactly represented by a\n"
15479                 "    floating-point variable and specifying \n"
15480                 "    offset2 as a number in the range from 0. to 1) the chance to minimize\n"
15481                 "    the numerical errors of the continuous time representation. \n"
15482                 "\n"
15483                 "    offset2 (PLFLT, input) :    See documentation of \n"
15484                 "    offset1. \n"
15485                 "\n"
15486                 "    ccontrol (PLINT, input) :     ccontrol contains bits controlling the\n"
15487                 "    transformation.  If the 0x1 bit is set, then the proleptic Julian\n"
15488                 "    calendar is used for broken-down time rather than the proleptic\n"
15489                 "    Gregorian calendar.  If the 0x2 bit is set, then leap seconds that\n"
15490                 "    have been historically used to define UTC are inserted into the\n"
15491                 "    broken-down time. Other possibilities for additional control bits\n"
15492                 "    for ccontrol exist such as making the historical time corrections\n"
15493                 "    in the broken-down time corresponding to ET (ephemeris time) or\n"
15494                 "    making the (slightly non-constant) corrections from international\n"
15495                 "    atomic time (TAI) to what astronomers define as terrestrial time\n"
15496                 "    (TT).  But those additional possibilities have not been\n"
15497                 "    implemented yet in the qsastime library (one of the PLplot utility\n"
15498                 "    libraries). \n"
15499                 "\n"
15500                 "    ifbtime_offset (PLBOOL, input) :    ifbtime_offset controls how the\n"
15501                 "    epoch of the continuous time scale is specified by the user. If \n"
15502                 "    ifbtime_offset is false, then \n"
15503                 "    offset1 and \n"
15504                 "    offset2 are used to specify the epoch, and the following broken-down\n"
15505                 "    time parameters are completely ignored.  If \n"
15506                 "    ifbtime_offset is true, then \n"
15507                 "    offset1 and \n"
15508                 "    offset2 are completely ignored, and the following broken-down time\n"
15509                 "    parameters are used to specify the epoch. \n"
15510                 "\n"
15511                 "    year (PLINT, input) :    Year of epoch. \n"
15512                 "\n"
15513                 "    month (PLINT, input) :    Month of epoch in range from 0 (January) to\n"
15514                 "    11 (December). \n"
15515                 "\n"
15516                 "    day (PLINT, input) :    Day of epoch in range from 1 to 31. \n"
15517                 "\n"
15518                 "    hour (PLINT, input) :    Hour of epoch in range from 0 to 23 \n"
15519                 "\n"
15520                 "    min (PLINT, input) :    Minute of epoch in range from 0 to 59. \n"
15521                 "\n"
15522                 "    sec (PLFLT, input) :    Second of epoch in floating range from 0. to\n"
15523                 "    60. \n"
15524                 "\n"
15525                 ""},
15526          { (char *)"plcont", _wrap_plcont, METH_VARARGS, (char *)"\n"
15527                 "Contour plot \n"
15528                 "\n"
15529                 "DESCRIPTION:\n"
15530                 "\n"
15531                 "    Draws a contour plot of the data in f[\n"
15532                 "    nx][\n"
15533                 "    ny], using the nlevel contour levels specified by clevel. Only the\n"
15534                 "    region of the array from kx to lx and from ky to ly is plotted out.  A\n"
15535                 "    transformation routine pointed to by pltr with a pointer pltr_data for\n"
15536                 "    additional data required by the transformation routine is used to map\n"
15537                 "    indices within the array to the world coordinates. See the following\n"
15538                 "    discussion of the arguments and the PLplot documentation for more\n"
15539                 "    information. \n"
15540                 "\n"
15541                 "    Redacted form: [PLEASE UPDATE! ONLY PERL INFO IS LIKELY CORRECT!] F95:\n"
15542                 "    plcont(f, kx, lx, ky, ly, clevel, tr?) or plcont(f, kx, lx, ky, ly,\n"
15543                 "    clevel, xgrid, ygrid)\n"
15544                 "           Java: pls.cont(f, kx, lx, ky, ly, clevel, xgrid, ygrid)\n"
15545                 "           Perl/PDL: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
15546                 "           Python: plcont2(f, kx, lx, ky, ly, clevel)\n"
15547                 "\n"
15548                 "\n"
15549                 "    This function is used in examples 9,14,16,22. \n"
15550                 "\n"
15551                 "\n"
15552                 "\n"
15553                 "SYNOPSIS:\n"
15554                 "\n"
15555                 "plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
15556                 "\n"
15557                 "ARGUMENTS:\n"
15558                 "\n"
15559                 "    f (const PLFLT * const *, input) :      Pointer to a vectored\n"
15560                 "    two-dimensional array containing data to be contoured. \n"
15561                 "\n"
15562                 "    nx, ny (PLINT, input) :    Physical dimensions of array f. \n"
15563                 "\n"
15564                 "    kx, lx (PLINT, input) :    Range of x indices to consider. \n"
15565                 "\n"
15566                 "    ky, ly (PLINT, input) :    Range of y indices to consider. \n"
15567                 "\n"
15568                 "    clevel (const PLFLT *, input) :    Pointer to array specifying levels\n"
15569                 "    at which to draw contours. \n"
15570                 "\n"
15571                 "    nlevel (PLINT, input) :    Number of contour levels to draw. \n"
15572                 "\n"
15573                 "    pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
15574                 "      Pointer to function that defines transformation between indices\n"
15575                 "    in array f and the world coordinates (C only).    Transformation\n"
15576                 "    functions are provided in the PLplot library: pltr0 for identity\n"
15577                 "    mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
15578                 "    defined by one- and two-dimensional arrays.  In addition,\n"
15579                 "    user-supplied routines for the transformation can be used as well.\n"
15580                 "     Examples of all of these approaches are given in the PLplot\n"
15581                 "    documentation. The transformation function should have the form\n"
15582                 "    given by any of pltr0, pltr1, or pltr2. Note that unlike plshades\n"
15583                 "    and similar PLplot functions which have a pltr argument, plcont\n"
15584                 "    requires that a transformation function be provided in the C\n"
15585                 "    interface.  Leaving  pltr NULL will result in an error. \n"
15586                 "\n"
15587                 "    pltr_data (PLPointer, input) :    Extra parameter to help pass\n"
15588                 "    information to pltr0, pltr1, pltr2, or whatever routine that is\n"
15589                 "    externally supplied. \n"
15590                 "\n"
15591                 ""},
15592          { (char *)"plctime", _wrap_plctime, METH_VARARGS, (char *)"\n"
15593                 "Calculate continuous time from broken-down time for the current stream \n"
15594                 "\n"
15595                 "DESCRIPTION:\n"
15596                 "\n"
15597                 "    Calculate continuous time, ctime, from broken-down time for the\n"
15598                 "    current stream.  The broken-down\n"
15599                 "    time is specified by the following parameters: year, month, day, hour,\n"
15600                 "    min, and sec. This function is the inverse of plbtime. \n"
15601                 "\n"
15602                 "    The PLplot definition of broken-down time is a calendar time that\n"
15603                 "    completely ignores all time zone offsets, i.e., it is the user's\n"
15604                 "    responsibility to apply those offsets (if so desired) before using the\n"
15605                 "    PLplot time API.  By default broken-down time is defined using the\n"
15606                 "    proleptic Gregorian calendar without the insertion of leap seconds and\n"
15607                 "    continuous time is defined as the number of seconds since the Unix\n"
15608                 "    epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
15609                 "    broken-down and continuous time are possible, see plconfigtime which\n"
15610                 "    specifies that transformation for the current stream. \n"
15611                 "\n"
15612                 "    Redacted form:  General: plctime(year, month, day, hour, min, sec,\n"
15613                 "    ctime)\n"
15614                 "           Perl/PDL: Not available? \n"
15615                 "\n"
15616                 "\n"
15617                 "    This function is used in example 29. \n"
15618                 "\n"
15619                 "\n"
15620                 "\n"
15621                 "SYNOPSIS:\n"
15622                 "\n"
15623                 "plctime(year, month, day, hour, min, sec, ctime)\n"
15624                 "\n"
15625                 "ARGUMENTS:\n"
15626                 "\n"
15627                 "    year (PLINT, input) :    Input year. \n"
15628                 "\n"
15629                 "    month (PLINT, input) :    Input month in range from 0 (January) to 11\n"
15630                 "    (December). \n"
15631                 "\n"
15632                 "    day (PLINT, input) :    Input day in range from 1 to 31. \n"
15633                 "\n"
15634                 "    hour (PLINT, input) :    Input hour in range from 0 to 23 \n"
15635                 "\n"
15636                 "    min (PLINT, input) :    Input minute in range from 0 to 59. \n"
15637                 "\n"
15638                 "    sec (PLFLT, input) :    Input second in floating range from 0. to 60. \n"
15639                 "\n"
15640                 "    ctime (PLFLT *, output) :     Continous time calculated from the\n"
15641                 "    broken-down time specified by the previous parameters. \n"
15642                 "\n"
15643                 ""},
15644          { (char *)"plcpstrm", _wrap_plcpstrm, METH_VARARGS, (char *)"\n"
15645                 "Copy state parameters from the reference stream to the current stream \n"
15646                 "\n"
15647                 "DESCRIPTION:\n"
15648                 "\n"
15649                 "    Copies state parameters from the reference stream to the current\n"
15650                 "    stream. Tell driver interface to map device coordinates unless flags\n"
15651                 "    == 1. \n"
15652                 "\n"
15653                 "    This function is used for making save files of selected plots (e.g.\n"
15654                 "    from the TK driver).  After initializing, you can get a copy of the\n"
15655                 "    current plot to the specified device by switching to this stream and\n"
15656                 "    issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
15657                 "    appropriate.  The plot buffer must have previously been enabled (done\n"
15658                 "    automatically by some display drivers, such as X). \n"
15659                 "\n"
15660                 "    Redacted form: plcpstrm(iplsr, flags)\n"
15661                 "\n"
15662                 "    This function is used in example 1,20. \n"
15663                 "\n"
15664                 "\n"
15665                 "\n"
15666                 "SYNOPSIS:\n"
15667                 "\n"
15668                 "plcpstrm(iplsr, flags)\n"
15669                 "\n"
15670                 "ARGUMENTS:\n"
15671                 "\n"
15672                 "    iplsr (PLINT, input) :    Number of reference stream. \n"
15673                 "\n"
15674                 "    flags (PLBOOL, input) :    If flags is set to true the device\n"
15675                 "    coordinates are not copied from the reference to current stream. \n"
15676                 "\n"
15677                 ""},
15678          { (char *)"plend", _wrap_plend, METH_VARARGS, (char *)"\n"
15679                 "End plotting session \n"
15680                 "\n"
15681                 "DESCRIPTION:\n"
15682                 "\n"
15683                 "    Ends a plotting session, tidies up all the output files, switches\n"
15684                 "    interactive devices back into text mode and frees up any memory that\n"
15685                 "    was allocated.  Must be called before end of program. \n"
15686                 "\n"
15687                 "    By default, PLplot's interactive devices (Xwin, TK, etc.)  go into a\n"
15688                 "    wait state after a call to plend or other functions which trigger the\n"
15689                 "    end of a plot page. To avoid this, use the plspause function. \n"
15690                 "\n"
15691                 "    Redacted form: plend()\n"
15692                 "\n"
15693                 "    This function is used in all of the examples. \n"
15694                 "\n"
15695                 "\n"
15696                 "\n"
15697                 "SYNOPSIS:\n"
15698                 "\n"
15699                 "plend()\n"
15700                 "\n"
15701                 ""},
15702          { (char *)"plend1", _wrap_plend1, METH_VARARGS, (char *)"\n"
15703                 "End plotting session for current stream \n"
15704                 "\n"
15705                 "DESCRIPTION:\n"
15706                 "\n"
15707                 "    Ends a plotting session for the current output stream only.  See\n"
15708                 "    plsstrm for more info. \n"
15709                 "\n"
15710                 "    Redacted form: plend1()\n"
15711                 "\n"
15712                 "    This function is used in examples 1,20. \n"
15713                 "\n"
15714                 "\n"
15715                 "\n"
15716                 "SYNOPSIS:\n"
15717                 "\n"
15718                 "plend1()\n"
15719                 "\n"
15720                 ""},
15721          { (char *)"plenv", _wrap_plenv, METH_VARARGS, (char *)"\n"
15722                 "Set up standard window and draw box \n"
15723                 "\n"
15724                 "DESCRIPTION:\n"
15725                 "\n"
15726                 "    Sets up plotter environment for simple graphs by calling pladv and\n"
15727                 "    setting up viewport and window to sensible default values. plenv\n"
15728                 "    leaves enough room around most graphs for axis labels and a title.\n"
15729                 "    When these defaults are not suitable, use the individual routines\n"
15730                 "    plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n"
15731                 "    defining the window, and plbox for drawing the box. \n"
15732                 "\n"
15733                 "    Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
15734                 "\n"
15735                 "    This function is used in example 1,3,9,13,14,19-22,29. \n"
15736                 "\n"
15737                 "\n"
15738                 "\n"
15739                 "SYNOPSIS:\n"
15740                 "\n"
15741                 "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
15742                 "\n"
15743                 "ARGUMENTS:\n"
15744                 "\n"
15745                 "    xmin (PLFLT, input) :    Value of x at left-hand edge of window (in\n"
15746                 "    world coordinates). \n"
15747                 "\n"
15748                 "    xmax (PLFLT, input) :    Value of x at right-hand edge of window (in\n"
15749                 "    world coordinates). \n"
15750                 "\n"
15751                 "    ymin (PLFLT, input) :    Value of y at bottom edge of window (in world\n"
15752                 "    coordinates). \n"
15753                 "\n"
15754                 "    ymax (PLFLT, input) :    Value of y at top edge of window (in world\n"
15755                 "    coordinates). \n"
15756                 "\n"
15757                 "    just (PLINT, input) :    Controls how the axes will be scaled: -1: the\n"
15758                 "    scales will not be set, the user must set up the scale before\n"
15759                 "    calling plenv using plsvpa, plvasp or other. \n"
15760                 "        0: the x and y axes are scaled independently to use as much of\n"
15761                 "        the screen as possible. \n"
15762                 "        1: the scales of the x and y axes are made equal. \n"
15763                 "        2: the axis of the x and y axes are made equal, and the plot\n"
15764                 "        box will be square. \n"
15765                 "\n"
15766                 "\n"
15767                 "    axis (PLINT, input) :    Controls drawing of the box around the plot:\n"
15768                 "    -2: draw no box, no tick marks, no numeric tick labels, no axes. \n"
15769                 "        -1: draw box only. \n"
15770                 "        0: draw box, ticks, and numeric tick labels. \n"
15771                 "        1: also draw coordinate axes at x=0 and y=0. \n"
15772                 "        2: also draw a grid at major tick positions in both\n"
15773                 "        coordinates. \n"
15774                 "        3: also draw a grid at minor tick positions in both\n"
15775                 "        coordinates. \n"
15776                 "        10: same as 0 except logarithmic x tick marks. (The x data\n"
15777                 "        have to be converted to logarithms separately.) \n"
15778                 "        11: same as 1 except logarithmic x tick marks. (The x data\n"
15779                 "        have to be converted to logarithms separately.) \n"
15780                 "        12: same as 2 except logarithmic x tick marks. (The x data\n"
15781                 "        have to be converted to logarithms separately.) \n"
15782                 "        13: same as 3 except logarithmic x tick marks. (The x data\n"
15783                 "        have to be converted to logarithms separately.) \n"
15784                 "        20: same as 0 except logarithmic y tick marks. (The y data\n"
15785                 "        have to be converted to logarithms separately.) \n"
15786                 "        21: same as 1 except logarithmic y tick marks. (The y data\n"
15787                 "        have to be converted to logarithms separately.) \n"
15788                 "        22: same as 2 except logarithmic y tick marks. (The y data\n"
15789                 "        have to be converted to logarithms separately.) \n"
15790                 "        23: same as 3 except logarithmic y tick marks. (The y data\n"
15791                 "        have to be converted to logarithms separately.) \n"
15792                 "        30: same as 0 except logarithmic x and y tick marks. (The x\n"
15793                 "        and y data have to be converted to logarithms separately.) \n"
15794                 "        31: same as 1 except logarithmic x and y tick marks. (The x\n"
15795                 "        and y data have to be converted to logarithms separately.) \n"
15796                 "        32: same as 2 except logarithmic x and y tick marks. (The x\n"
15797                 "        and y data have to be converted to logarithms separately.) \n"
15798                 "        33: same as 3 except logarithmic x and y tick marks. (The x\n"
15799                 "        and y data have to be converted to logarithms separately.) \n"
15800                 "        40: same as 0 except date / time x labels.    \n"
15801                 "        41: same as 1 except date / time x labels.    \n"
15802                 "        42: same as 2 except date / time x labels.    \n"
15803                 "        43: same as 3 except date / time x labels.    \n"
15804                 "        50: same as 0 except date / time y labels.    \n"
15805                 "        51: same as 1 except date / time y labels.    \n"
15806                 "        52: same as 2 except date / time y labels. \n"
15807                 "        53: same as 3 except date / time y labels.    \n"
15808                 "        60: same as 0 except date / time x and y labels.  \n"
15809                 "        61: same as 1 except date / time x and y labels.  \n"
15810                 "        62: same as 2 except date / time x and y labels.  \n"
15811                 "        63: same as 3 except date / time x and y labels. \n"
15812                 "        70: same as 0 except custom x and y labels. \n"
15813                 "        71: same as 1 except custom x and y labels. \n"
15814                 "        72: same as 2 except custom x and y labels. \n"
15815                 "        73: same as 3 except custom x and y labels. \n"
15816                 "\n"
15817                 ""},
15818          { (char *)"plenv0", _wrap_plenv0, METH_VARARGS, (char *)"\n"
15819                 "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it \n"
15820                 "\n"
15821                 "DESCRIPTION:\n"
15822                 "\n"
15823                 "    Sets up plotter environment for simple graphs by calling pladv and\n"
15824                 "    setting up viewport and window to sensible default values. plenv0\n"
15825                 "    leaves enough room around most graphs for axis labels and a title.\n"
15826                 "    When these defaults are not suitable, use the individual routines\n"
15827                 "    plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n"
15828                 "    defining the window, and plbox for drawing the box. \n"
15829                 "\n"
15830                 "    Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
15831                 "\n"
15832                 "    This function is used in example 21. \n"
15833                 "\n"
15834                 "\n"
15835                 "\n"
15836                 "SYNOPSIS:\n"
15837                 "\n"
15838                 "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
15839                 "\n"
15840                 "ARGUMENTS:\n"
15841                 "\n"
15842                 "    xmin (PLFLT, input) :    Value of x at left-hand edge of window (in\n"
15843                 "    world coordinates). \n"
15844                 "\n"
15845                 "    xmax (PLFLT, input) :    Value of x at right-hand edge of window (in\n"
15846                 "    world coordinates). \n"
15847                 "\n"
15848                 "    ymin (PLFLT, input) :    Value of y at bottom edge of window (in world\n"
15849                 "    coordinates). \n"
15850                 "\n"
15851                 "    ymax (PLFLT, input) :    Value of y at top edge of window (in world\n"
15852                 "    coordinates). \n"
15853                 "\n"
15854                 "    just (PLINT, input) :    Controls how the axes will be scaled: -1: the\n"
15855                 "    scales will not be set, the user must set up the scale before\n"
15856                 "    calling plenv0 using plsvpa, plvasp or other. \n"
15857                 "        0: the x and y axes are scaled independently to use as much of\n"
15858                 "        the screen as possible. \n"
15859                 "        1: the scales of the x and y axes are made equal. \n"
15860                 "        2: the axis of the x and y axes are made equal, and the plot\n"
15861                 "        box will be square. \n"
15862                 "\n"
15863                 "\n"
15864                 "    axis (PLINT, input) :    Controls drawing of the box around the plot:\n"
15865                 "    -2: draw no box, no tick marks, no numeric tick labels, no axes. \n"
15866                 "        -1: draw box only. \n"
15867                 "        0: draw box, ticks, and numeric tick labels. \n"
15868                 "        1: also draw coordinate axes at x=0 and y=0. \n"
15869                 "        2: also draw a grid at major tick positions in both\n"
15870                 "        coordinates. \n"
15871                 "        3: also draw a grid at minor tick positions in both\n"
15872                 "        coordinates. \n"
15873                 "        10: same as 0 except logarithmic x tick marks. (The x data\n"
15874                 "        have to be converted to logarithms separately.) \n"
15875                 "        11: same as 1 except logarithmic x tick marks. (The x data\n"
15876                 "        have to be converted to logarithms separately.) \n"
15877                 "        12: same as 2 except logarithmic x tick marks. (The x data\n"
15878                 "        have to be converted to logarithms separately.) \n"
15879                 "        13: same as 3 except logarithmic x tick marks. (The x data\n"
15880                 "        have to be converted to logarithms separately.) \n"
15881                 "        20: same as 0 except logarithmic y tick marks. (The y data\n"
15882                 "        have to be converted to logarithms separately.) \n"
15883                 "        21: same as 1 except logarithmic y tick marks. (The y data\n"
15884                 "        have to be converted to logarithms separately.) \n"
15885                 "        22: same as 2 except logarithmic y tick marks. (The y data\n"
15886                 "        have to be converted to logarithms separately.) \n"
15887                 "        23: same as 3 except logarithmic y tick marks. (The y data\n"
15888                 "        have to be converted to logarithms separately.) \n"
15889                 "        30: same as 0 except logarithmic x and y tick marks. (The x\n"
15890                 "        and y data have to be converted to logarithms separately.) \n"
15891                 "        31: same as 1 except logarithmic x and y tick marks. (The x\n"
15892                 "        and y data have to be converted to logarithms separately.) \n"
15893                 "        32: same as 2 except logarithmic x and y tick marks. (The x\n"
15894                 "        and y data have to be converted to logarithms separately.) \n"
15895                 "        33: same as 3 except logarithmic x and y tick marks. (The x\n"
15896                 "        and y data have to be converted to logarithms separately.) \n"
15897                 "        40: same as 0 except date / time x labels.    \n"
15898                 "        41: same as 1 except date / time x labels.    \n"
15899                 "        42: same as 2 except date / time x labels.    \n"
15900                 "        43: same as 3 except date / time x labels.    \n"
15901                 "        50: same as 0 except date / time y labels.    \n"
15902                 "        51: same as 1 except date / time y labels.    \n"
15903                 "        52: same as 2 except date / time y labels. \n"
15904                 "        53: same as 3 except date / time y labels.    \n"
15905                 "        60: same as 0 except date / time x and y labels.  \n"
15906                 "        61: same as 1 except date / time x and y labels.  \n"
15907                 "        62: same as 2 except date / time x and y labels.  \n"
15908                 "        63: same as 3 except date / time x and y labels. \n"
15909                 "        70: same as 0 except custom x and y labels. \n"
15910                 "        71: same as 1 except custom x and y labels. \n"
15911                 "        72: same as 2 except custom x and y labels. \n"
15912                 "        73: same as 3 except custom x and y labels. \n"
15913                 "\n"
15914                 ""},
15915          { (char *)"pleop", _wrap_pleop, METH_VARARGS, (char *)"\n"
15916                 "Eject current page \n"
15917                 "\n"
15918                 "DESCRIPTION:\n"
15919                 "\n"
15920                 "    Clears the graphics screen of an interactive device, or ejects a page\n"
15921                 "    on a plotter.  See plbop for more information. \n"
15922                 "\n"
15923                 "    Redacted form: pleop()\n"
15924                 "\n"
15925                 "    This function is used in example 2,14. \n"
15926                 "\n"
15927                 "\n"
15928                 "\n"
15929                 "SYNOPSIS:\n"
15930                 "\n"
15931                 "pleop()\n"
15932                 "\n"
15933                 ""},
15934          { (char *)"plerrx", _wrap_plerrx, METH_VARARGS, (char *)"\n"
15935                 "Draw x error bar \n"
15936                 "\n"
15937                 "DESCRIPTION:\n"
15938                 "\n"
15939                 "    Draws a set of n horizontal error bars, the i'th error bar extending\n"
15940                 "    from xmin[i] to xmax[i] at y coordinate y[i].  The terminals of the\n"
15941                 "    error bar are of length equal to the minor tick length (settable using\n"
15942                 "    plsmin). \n"
15943                 "\n"
15944                 "    Redacted form:  General: plerrx(xmin, ymax, y)\n"
15945                 "           Perl/PDL: plerrx(n, xmin, xmax, y)\n"
15946                 "\n"
15947                 "\n"
15948                 "    This function is used in example 29. \n"
15949                 "\n"
15950                 "\n"
15951                 "\n"
15952                 "SYNOPSIS:\n"
15953                 "\n"
15954                 "plerrx(n, xmin, xmax, y)\n"
15955                 "\n"
15956                 "ARGUMENTS:\n"
15957                 "\n"
15958                 "    n (PLINT, input) :      Number of error bars to draw. \n"
15959                 "\n"
15960                 "    xmin (const PLFLT *, input) :    Pointer to array with x coordinates\n"
15961                 "    of left-hand endpoint of error bars. \n"
15962                 "\n"
15963                 "    xmax (const PLFLT *, input) :    Pointer to array with x coordinates\n"
15964                 "    of right-hand endpoint of error bars. \n"
15965                 "\n"
15966                 "    y (const PLFLT *, input) :      Pointer to array with y coordinates of\n"
15967                 "    error bar. \n"
15968                 "\n"
15969                 ""},
15970          { (char *)"plerry", _wrap_plerry, METH_VARARGS, (char *)"\n"
15971                 "Draw y error bar \n"
15972                 "\n"
15973                 "DESCRIPTION:\n"
15974                 "\n"
15975                 "    Draws a set of n vertical error bars, the i'th error bar extending\n"
15976                 "    from ymin[i] to ymax[i] at x coordinate x[i].  The terminals of the\n"
15977                 "    error bar are of length equal to the minor tick length (settable using\n"
15978                 "    plsmin). \n"
15979                 "\n"
15980                 "    Redacted form:  General: plerry(x, ymin, ymax)\n"
15981                 "           Perl/PDL: plerry(n, x, ymin, ymax)\n"
15982                 "\n"
15983                 "\n"
15984                 "    This function is used in example 29. \n"
15985                 "\n"
15986                 "\n"
15987                 "\n"
15988                 "SYNOPSIS:\n"
15989                 "\n"
15990                 "plerry(n, x, ymin, ymax)\n"
15991                 "\n"
15992                 "ARGUMENTS:\n"
15993                 "\n"
15994                 "    n (PLINT, input) :      Number of error bars to draw. \n"
15995                 "\n"
15996                 "    x (const PLFLT *, input) :      Pointer to array with x coordinates of\n"
15997                 "    error bars. \n"
15998                 "\n"
15999                 "    ymin (const PLFLT *, input) :    Pointer to array with y coordinates\n"
16000                 "    of lower endpoint of error bars. \n"
16001                 "\n"
16002                 "    ymax (const PLFLT *, input) :    Pointer to array with y coordinate of\n"
16003                 "    upper endpoint of error bar. \n"
16004                 "\n"
16005                 ""},
16006          { (char *)"plfamadv", _wrap_plfamadv, METH_VARARGS, (char *)"\n"
16007                 "Advance to the next family file on the next new page \n"
16008                 "\n"
16009                 "DESCRIPTION:\n"
16010                 "\n"
16011                 "    Advance to the next family file on the next new page. \n"
16012                 "\n"
16013                 "    Redacted form: plfamadv()\n"
16014                 "\n"
16015                 "    This function is not used in any examples. \n"
16016                 "\n"
16017                 "\n"
16018                 "\n"
16019                 "SYNOPSIS:\n"
16020                 "\n"
16021                 "plfamadv()\n"
16022                 "\n"
16023                 ""},
16024          { (char *)"plfill", _wrap_plfill, METH_VARARGS, (char *)"\n"
16025                 "Draw filled polygon \n"
16026                 "\n"
16027                 "DESCRIPTION:\n"
16028                 "\n"
16029                 "    Fills the polygon defined by the n points (\n"
16030                 "    x[i], \n"
16031                 "    y[i]) using the pattern defined by plpsty or plpat.  The default fill\n"
16032                 "    style is a solid fill.  The routine will automatically close the\n"
16033                 "    polygon between the last and first vertices.  If multiple closed\n"
16034                 "    polygons are passed in x and y then plfill will fill in between them. \n"
16035                 "\n"
16036                 "    Redacted form: plfill(x,y)\n"
16037                 "\n"
16038                 "    This function is used in examples 12,13,15,16,21,24,25. \n"
16039                 "\n"
16040                 "\n"
16041                 "\n"
16042                 "SYNOPSIS:\n"
16043                 "\n"
16044                 "plfill(n, x, y)\n"
16045                 "\n"
16046                 "ARGUMENTS:\n"
16047                 "\n"
16048                 "    n (PLINT, input) :      Number of vertices in polygon. \n"
16049                 "\n"
16050                 "    x (const PLFLT *, input) :      Pointer to array with x coordinates of\n"
16051                 "    vertices. \n"
16052                 "\n"
16053                 "    y (const PLFLT *, input) :      Pointer to array with y coordinates of\n"
16054                 "    vertices. \n"
16055                 "\n"
16056                 ""},
16057          { (char *)"plfill3", _wrap_plfill3, METH_VARARGS, (char *)"\n"
16058                 "Draw filled polygon in 3D \n"
16059                 "\n"
16060                 "DESCRIPTION:\n"
16061                 "\n"
16062                 "    Fills the 3D polygon defined by the n points in the x, y, and z arrays\n"
16063                 "    using the pattern defined by plpsty or plpat.  The routine will\n"
16064                 "    automatically close the polygon between the last and first vertices. \n"
16065                 "    If multiple closed polygons are passed in x, y, and z then plfill3\n"
16066                 "    will fill in between them. \n"
16067                 "\n"
16068                 "    Redacted form:  General: plfill3(x, y, z)\n"
16069                 "           Perl/PDL: plfill3(n, x, y, z)\n"
16070                 "\n"
16071                 "\n"
16072                 "    This function is used in example 15. \n"
16073                 "\n"
16074                 "\n"
16075                 "\n"
16076                 "SYNOPSIS:\n"
16077                 "\n"
16078                 "plfill3(n, x, y, z)\n"
16079                 "\n"
16080                 "ARGUMENTS:\n"
16081                 "\n"
16082                 "    n (PLINT, input) :      Number of vertices in polygon. \n"
16083                 "\n"
16084                 "    x (const PLFLT *, input) :      Pointer to array with x coordinates of\n"
16085                 "    vertices. \n"
16086                 "\n"
16087                 "    y (const PLFLT *, input) :      Pointer to array with y coordinates of\n"
16088                 "    vertices. \n"
16089                 "\n"
16090                 "    z (const PLFLT *, input) :      Pointer to array with z coordinates of\n"
16091                 "    vertices. \n"
16092                 "\n"
16093                 ""},
16094          { (char *)"plgradient", _wrap_plgradient, METH_VARARGS, (char *)"\n"
16095                 "Draw linear gradient inside polygon \n"
16096                 "\n"
16097                 "DESCRIPTION:\n"
16098                 "\n"
16099                 "    Draw a linear gradient using colour map 1 inside the polygon defined\n"
16100                 "    by the n points (\n"
16101                 "    x[i], \n"
16102                 "    y[i]).  Interpretation of the polygon is the same as for plfill.  The\n"
16103                 "    polygon coordinates and the gradient angle are all expressed in world\n"
16104                 "    coordinates.  The angle from the x axis for both the rotated\n"
16105                 "    coordinate system and the gradient vector is specified by angle.  The\n"
16106                 "    magnitude of the gradient vector is the difference between the maximum\n"
16107                 "    and minimum values of x for the vertices in the rotated coordinate\n"
16108                 "    system.  The origin of the gradient vector can be interpreted as being\n"
16109                 "    anywhere on the line corresponding to the minimum x value for the\n"
16110                 "    vertices in the rotated coordinate system. The distance along the\n"
16111                 "    gradient vector is linearly transformed to the independent variable of\n"
16112                 "    colour map 1 which ranges from 0. at the tail of the gradient vector\n"
16113                 "    to 1. at the head of the gradient vector.  What is drawn is the RGBA\n"
16114                 "    colour corresponding to the independent variable of colour map 1.  For\n"
16115                 "    more information about colour map 1 (see the PLplot documentation). \n"
16116                 "\n"
16117                 "    Redacted form: plgradient(x,y,angle)\n"
16118                 "\n"
16119                 "    This function is used in examples 25,30. \n"
16120                 "\n"
16121                 "\n"
16122                 "\n"
16123                 "SYNOPSIS:\n"
16124                 "\n"
16125                 "plgradient(n, x, y, angle)\n"
16126                 "\n"
16127                 "ARGUMENTS:\n"
16128                 "\n"
16129                 "    n (PLINT, input) :      Number of vertices in polygon. \n"
16130                 "\n"
16131                 "    x (const PLFLT *, input) :      Pointer to array with x coordinates of\n"
16132                 "    vertices. \n"
16133                 "\n"
16134                 "    y (const PLFLT *, input) :      Pointer to array with y coordinates of\n"
16135                 "    vertices. \n"
16136                 "\n"
16137                 "    angle (PLFLT, input) :    Angle (degrees) of gradient vector from x\n"
16138                 "    axis. \n"
16139                 "\n"
16140                 ""},
16141          { (char *)"plflush", _wrap_plflush, METH_VARARGS, (char *)"\n"
16142                 "Flushes the output stream \n"
16143                 "\n"
16144                 "DESCRIPTION:\n"
16145                 "\n"
16146                 "    Flushes the output stream. Use sparingly, if at all. \n"
16147                 "\n"
16148                 "    Redacted form: plflush()\n"
16149                 "\n"
16150                 "    This function is used in examples 1,14. \n"
16151                 "\n"
16152                 "\n"
16153                 "\n"
16154                 "SYNOPSIS:\n"
16155                 "\n"
16156                 "plflush()\n"
16157                 "\n"
16158                 ""},
16159          { (char *)"plfont", _wrap_plfont, METH_VARARGS, (char *)"\n"
16160                 "Set character font \n"
16161                 "\n"
16162                 "DESCRIPTION:\n"
16163                 "\n"
16164                 "    Sets the default character font for subsequent character drawing. Also\n"
16165                 "    affects symbols produced by plpoin.  This routine has no effect unless\n"
16166                 "    the extended character set is loaded (see plfontld). \n"
16167                 "\n"
16168                 "    Redacted form: plfont(ifont)\n"
16169                 "\n"
16170                 "    This function is used in examples 1,2,4,7,13,24,26. \n"
16171                 "\n"
16172                 "\n"
16173                 "\n"
16174                 "SYNOPSIS:\n"
16175                 "\n"
16176                 "plfont(ifont)\n"
16177                 "\n"
16178                 "ARGUMENTS:\n"
16179                 "\n"
16180                 "    ifont (PLINT, input) :    Specifies the font: 1: Normal font (simplest\n"
16181                 "    and fastest) \n"
16182                 "        2: Roman font \n"
16183                 "        3: Italic font \n"
16184                 "        4: Script font \n"
16185                 "\n"
16186                 ""},
16187          { (char *)"plfontld", _wrap_plfontld, METH_VARARGS, (char *)"\n"
16188                 "Load character font \n"
16189                 "\n"
16190                 "DESCRIPTION:\n"
16191                 "\n"
16192                 "    Sets the character set to use for subsequent character drawing.  May\n"
16193                 "    be called before initializing PLplot. \n"
16194                 "\n"
16195                 "    Redacted form: plfontld(fnt)\n"
16196                 "\n"
16197                 "    This function is used in examples 1,7. \n"
16198                 "\n"
16199                 "\n"
16200                 "\n"
16201                 "SYNOPSIS:\n"
16202                 "\n"
16203                 "plfontld(fnt)\n"
16204                 "\n"
16205                 "ARGUMENTS:\n"
16206                 "\n"
16207                 "    fnt (PLINT, input) :    Specifies the character set to load: 0:\n"
16208                 "    Standard character set \n"
16209                 "        1: Extended character set \n"
16210                 "\n"
16211                 ""},
16212          { (char *)"plgchr", _wrap_plgchr, METH_VARARGS, (char *)"\n"
16213                 "Get character default height and current (scaled) height \n"
16214                 "\n"
16215                 "DESCRIPTION:\n"
16216                 "\n"
16217                 "    Get character default height and current (scaled) height. \n"
16218                 "\n"
16219                 "    Redacted form: plgchr(p_def, p_ht)\n"
16220                 "\n"
16221                 "    This function is used in example 23. \n"
16222                 "\n"
16223                 "\n"
16224                 "\n"
16225                 "SYNOPSIS:\n"
16226                 "\n"
16227                 "plgchr(p_def, p_ht)\n"
16228                 "\n"
16229                 "ARGUMENTS:\n"
16230                 "\n"
16231                 "    p_def (PLFLT *, output) :     Pointer to default character height (mm). \n"
16232                 "\n"
16233                 "    p_ht (PLFLT *, output) :    Pointer to current (scaled) character\n"
16234                 "    height (mm). \n"
16235                 "\n"
16236                 ""},
16237          { (char *)"plgcol0", _wrap_plgcol0, METH_VARARGS, (char *)"\n"
16238                 "Returns 8-bit RGB values for given color index from cmap0 \n"
16239                 "\n"
16240                 "DESCRIPTION:\n"
16241                 "\n"
16242                 "    Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n"
16243                 "    PLplot documentation).  Values are negative if an invalid color id is\n"
16244                 "    given. \n"
16245                 "\n"
16246                 "    Redacted form: plgcol0(icol0, r, g, b)\n"
16247                 "\n"
16248                 "    This function is used in example 2. \n"
16249                 "\n"
16250                 "\n"
16251                 "\n"
16252                 "SYNOPSIS:\n"
16253                 "\n"
16254                 "plgcol0(icol0, r, g, b)\n"
16255                 "\n"
16256                 "ARGUMENTS:\n"
16257                 "\n"
16258                 "    icol0 (PLINT, input) :    Index of desired cmap0 color. \n"
16259                 "\n"
16260                 "    r (PLINT *, output) :    Pointer to 8-bit red value. \n"
16261                 "\n"
16262                 "    g (PLINT *, output) :    Pointer to 8-bit green value. \n"
16263                 "\n"
16264                 "    b (PLINT *, output) :    Pointer to 8-bit blue value. \n"
16265                 "\n"
16266                 ""},
16267          { (char *)"plgcol0a", _wrap_plgcol0a, METH_VARARGS, (char *)"\n"
16268                 "Returns 8-bit RGB values and double alpha transparency value for given color index from cmap0 \n"
16269                 "\n"
16270                 "DESCRIPTION:\n"
16271                 "\n"
16272                 "    Returns 8-bit RGB values (0-255) and double alpha transparency value\n"
16273                 "    (0.0 - 1.0) for  given color from cmap0 (see the PLplot\n"
16274                 "    documentation).  Values  are negative if an invalid color id is given. \n"
16275                 "\n"
16276                 "    This function is used in example 30. \n"
16277                 "\n"
16278                 "\n"
16279                 "\n"
16280                 "SYNOPSIS:\n"
16281                 "\n"
16282                 "plgcol0a(icol0, r, g, b, alpha)\n"
16283                 "\n"
16284                 "ARGUMENTS:\n"
16285                 "\n"
16286                 "    icol0 (PLINT, input) :    Index of desired cmap0 color. \n"
16287                 "\n"
16288                 "    r (PLINT *, output) :    Pointer to 8-bit red value. \n"
16289                 "\n"
16290                 "    g (PLINT *, output) :    Pointer to 8-bit green value. \n"
16291                 "\n"
16292                 "    b (PLINT *, output) :    Pointer to 8-bit blue value. \n"
16293                 "\n"
16294                 "    alpha (PLFLT *, output) :     Pointer to PLFLT alpha transparency\n"
16295                 "    value. \n"
16296                 "\n"
16297                 ""},
16298          { (char *)"plgcolbg", _wrap_plgcolbg, METH_VARARGS, (char *)"\n"
16299                 "Returns the background color (cmap0[0]) by 8-bit RGB value \n"
16300                 "\n"
16301                 "ESCRIPTION:\n"
16302                 "\n"
16303                 "   Returns the background color (cmap0[0]) by 8-bit RGB value. \n"
16304                 "\n"
16305                 "   Redacted form: plgcolbg(r, g, b)\n"
16306                 "\n"
16307                 "   This function is used in example 31. \n"
16308                 "\n"
16309                 "\n"
16310                 "\n"
16311                 "YNOPSIS:\n"
16312                 "\n"
16313                 "lgcolbg(r, g, b)\n"
16314                 "\n"
16315                 "RGUMENTS:\n"
16316                 "\n"
16317                 "   r (PLINT *, output) :    Pointer to an unsigned 8-bit integer (0-255)\n"
16318                 "   representing the degree of red in the color. \n"
16319                 "\n"
16320                 "   g (PLINT *, output) :    Pointer to an unsigned 8-bit integer (0-255)\n"
16321                 "   representing the degree of green in the color. \n"
16322                 "\n"
16323                 "   b (PLINT *, output) :    Pointer to an unsigned 8-bit integer (0-255)\n"
16324                 "   representing the degree of blue in the color. \n"
16325                 "\n"
16326                 ""},
16327          { (char *)"plgcolbga", _wrap_plgcolbga, METH_VARARGS, (char *)"\n"
16328                 "Returns the background color (cmap0[0])  by 8-bit RGB value and double alpha transparency value \n"
16329                 "\n"
16330                 "ESCRIPTION:\n"
16331                 "\n"
16332                 "   Returns the background color (cmap0[0]) by 8-bit RGB value and double\n"
16333                 "   alpha transparency value. \n"
16334                 "\n"
16335                 "   This function is used in example 31. \n"
16336                 "\n"
16337                 "\n"
16338                 "\n"
16339                 "YNOPSIS:\n"
16340                 "\n"
16341                 "lgcolbga(r, g, b, alpha)\n"
16342                 "\n"
16343                 "RGUMENTS:\n"
16344                 "\n"
16345                 "   r (PLINT *, output) :    Pointer to an unsigned 8-bit integer (0-255)\n"
16346                 "   representing the degree of red in the color. \n"
16347                 "\n"
16348                 "   g (PLINT *, output) :    Pointer to an unsigned 8-bit integer (0-255)\n"
16349                 "   representing the degree of green in the color. \n"
16350                 "\n"
16351                 "   b (PLINT *, output) :    Pointer to an unsigned 8-bit integer (0-255)\n"
16352                 "   representing the degree of blue in the color. \n"
16353                 "\n"
16354                 "   alpha (PLFLT *, output) :     Pointer to PLFLT alpha transparency\n"
16355                 "   value. \n"
16356                 "\n"
16357                 ""},
16358          { (char *)"plgcompression", _wrap_plgcompression, METH_VARARGS, (char *)"\n"
16359                 "Get the current device-compression setting \n"
16360                 "\n"
16361                 "DESCRIPTION:\n"
16362                 "\n"
16363                 "    Get the current device-compression setting.  This parameter is only\n"
16364                 "    used for drivers that provide compression. \n"
16365                 "\n"
16366                 "    Redacted form: plgcompression(compression)\n"
16367                 "\n"
16368                 "    This function is used in example 31. \n"
16369                 "\n"
16370                 "\n"
16371                 "\n"
16372                 "SYNOPSIS:\n"
16373                 "\n"
16374                 "plgcompression(compression)\n"
16375                 "\n"
16376                 "ARGUMENTS:\n"
16377                 "\n"
16378                 "    compression (PLINT *, output) :    Pointer to a variable to be filled\n"
16379                 "    with the current device-compression setting. \n"
16380                 "\n"
16381                 ""},
16382          { (char *)"plgdev", _wrap_plgdev, METH_VARARGS, (char *)"\n"
16383                 "Get the current device (keyword) name \n"
16384                 "\n"
16385                 "DESCRIPTION:\n"
16386                 "\n"
16387                 "    Get the current device (keyword) name.  Note: you must have allocated\n"
16388                 "    space for this (80 characters is safe). \n"
16389                 "\n"
16390                 "    Redacted form: plgdev(p_dev)\n"
16391                 "\n"
16392                 "    This function is used in example 14. \n"
16393                 "\n"
16394                 "\n"
16395                 "\n"
16396                 "SYNOPSIS:\n"
16397                 "\n"
16398                 "plgdev(p_dev)\n"
16399                 "\n"
16400                 "ARGUMENTS:\n"
16401                 "\n"
16402                 "    p_dev (char *, output) :    Pointer to device (keyword) name string. \n"
16403                 "\n"
16404                 ""},
16405          { (char *)"plgdidev", _wrap_plgdidev, METH_VARARGS, (char *)"\n"
16406                 "Get parameters that define current device-space window \n"
16407                 "\n"
16408                 "DESCRIPTION:\n"
16409                 "\n"
16410                 "    Get relative margin width, aspect ratio, and relative justification\n"
16411                 "    that define current device-space window. If plsdidev has not been\n"
16412                 "    called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
16413                 "    p_jy will all be 0. \n"
16414                 "\n"
16415                 "    Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16416                 "\n"
16417                 "    This function is used in example 31. \n"
16418                 "\n"
16419                 "\n"
16420                 "\n"
16421                 "SYNOPSIS:\n"
16422                 "\n"
16423                 "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16424                 "\n"
16425                 "ARGUMENTS:\n"
16426                 "\n"
16427                 "    p_mar (PLFLT *, output) :     Pointer to relative margin width. \n"
16428                 "\n"
16429                 "    p_aspect (PLFLT *, output) :    Pointer to aspect ratio. \n"
16430                 "\n"
16431                 "    p_jx (PLFLT *, output) :    Pointer to relative justification in x. \n"
16432                 "\n"
16433                 "    p_jy (PLFLT *, output) :    Pointer to relative justification in y. \n"
16434                 "\n"
16435                 ""},
16436          { (char *)"plgdiori", _wrap_plgdiori, METH_VARARGS, (char *)"\n"
16437                 "Get plot orientation \n"
16438                 "\n"
16439                 "DESCRIPTION:\n"
16440                 "\n"
16441                 "    Get plot orientation parameter which is multiplied by 90 degrees to\n"
16442                 "    obtain the angle of rotation.  Note, arbitrary rotation parameters\n"
16443                 "    such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
16444                 "    values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
16445                 "    to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
16446                 "    (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
16447                 "    not been called the default value pointed to by p_rot will be 0. \n"
16448                 "\n"
16449                 "    Redacted form: plgdiori(p_rot)\n"
16450                 "\n"
16451                 "    This function is not used in any examples. \n"
16452                 "\n"
16453                 "\n"
16454                 "\n"
16455                 "SYNOPSIS:\n"
16456                 "\n"
16457                 "plgdiori(p_rot)\n"
16458                 "\n"
16459                 "ARGUMENTS:\n"
16460                 "\n"
16461                 "    p_rot (PLFLT *, output) :     Pointer to orientation parameter. \n"
16462                 "\n"
16463                 ""},
16464          { (char *)"plgdiplt", _wrap_plgdiplt, METH_VARARGS, (char *)"\n"
16465                 "Get parameters that define current plot-space window \n"
16466                 "\n"
16467                 "DESCRIPTION:\n"
16468                 "\n"
16469                 "    Get relative minima and maxima that define current plot-space window.\n"
16470                 "    If plsdiplt has not been called the default values pointed to by\n"
16471                 "    p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1. \n"
16472                 "\n"
16473                 "    Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16474                 "\n"
16475                 "    This function is used in example 31. \n"
16476                 "\n"
16477                 "\n"
16478                 "\n"
16479                 "SYNOPSIS:\n"
16480                 "\n"
16481                 "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16482                 "\n"
16483                 "ARGUMENTS:\n"
16484                 "\n"
16485                 "    p_xmin (PLFLT *, output) :      Pointer to relative minimum in x. \n"
16486                 "\n"
16487                 "    p_ymin (PLFLT *, output) :      Pointer to relative minimum in y. \n"
16488                 "\n"
16489                 "    p_xmax (PLFLT *, output) :      Pointer to relative maximum in x. \n"
16490                 "\n"
16491                 "    p_ymax (PLFLT *, output) :      Pointer to relative maximum in y. \n"
16492                 "\n"
16493                 ""},
16494          { (char *)"plgfam", _wrap_plgfam, METH_VARARGS, (char *)"\n"
16495                 "Get family file parameters \n"
16496                 "\n"
16497                 "DESCRIPTION:\n"
16498                 "\n"
16499                 "    Gets information about current family file, if familying is enabled. \n"
16500                 "    See the PLplot documentation for more information. \n"
16501                 "\n"
16502                 "    Redacted form: plgfam(p_fam, p_num, p_bmax)\n"
16503                 "\n"
16504                 "    This function is used in examples 14,31. \n"
16505                 "\n"
16506                 "\n"
16507                 "\n"
16508                 "SYNOPSIS:\n"
16509                 "\n"
16510                 "plgfam(p_fam, p_num, p_bmax)\n"
16511                 "\n"
16512                 "ARGUMENTS:\n"
16513                 "\n"
16514                 "    p_fam (PLINT *, output) :     Pointer to variable with the Boolean\n"
16515                 "    family flag value.  If nonzero, familying is enabled. \n"
16516                 "\n"
16517                 "    p_num (PLINT *, output) :     Pointer to variable with the current\n"
16518                 "    family file number. \n"
16519                 "\n"
16520                 "    p_bmax (PLINT *, output) :      Pointer to variable with the maximum\n"
16521                 "    file size (in bytes) for a family file. \n"
16522                 "\n"
16523                 ""},
16524          { (char *)"plgfci", _wrap_plgfci, METH_VARARGS, (char *)"\n"
16525                 "Get FCI (font characterization integer) \n"
16526                 "\n"
16527                 "DESCRIPTION:\n"
16528                 "\n"
16529                 "    Gets information about the current font using the FCI approach. See\n"
16530                 "    the PLplot documentation for more information. \n"
16531                 "\n"
16532                 "    Redacted form: plgfci(p_fci)\n"
16533                 "\n"
16534                 "    This function is used in example 23. \n"
16535                 "\n"
16536                 "\n"
16537                 "\n"
16538                 "SYNOPSIS:\n"
16539                 "\n"
16540                 "plgfci(p_fci)\n"
16541                 "\n"
16542                 "ARGUMENTS:\n"
16543                 "\n"
16544                 "    p_fci (PLUNICODE *, output) :    Pointer to PLUNICODE (unsigned 32-bit\n"
16545                 "    integer) variable which is updated with current FCI value. \n"
16546                 "\n"
16547                 ""},
16548          { (char *)"plgfnam", _wrap_plgfnam, METH_VARARGS, (char *)"\n"
16549                 "Get output file name \n"
16550                 "\n"
16551                 "DESCRIPTION:\n"
16552                 "\n"
16553                 "    Gets the current output file name, if applicable. \n"
16554                 "\n"
16555                 "    Redacted form: plgfnam(fnam)\n"
16556                 "\n"
16557                 "    This function is used in example 31. \n"
16558                 "\n"
16559                 "\n"
16560                 "\n"
16561                 "SYNOPSIS:\n"
16562                 "\n"
16563                 "plgfnam(fnam)\n"
16564                 "\n"
16565                 "ARGUMENTS:\n"
16566                 "\n"
16567                 "    fnam (char *, output) :    Pointer to file name string (a preallocated\n"
16568                 "    string of 80 characters or more). \n"
16569                 "\n"
16570                 ""},
16571          { (char *)"plgfont", _wrap_plgfont, METH_VARARGS, (char *)"\n"
16572                 "Get family, style and weight of the current font \n"
16573                 "\n"
16574                 "DESCRIPTION:\n"
16575                 "\n"
16576                 "    Gets information about current font.  See the PLplot documentation for\n"
16577                 "    more information on font selection. \n"
16578                 "\n"
16579                 "    Redacted form: plgfont(p_family, p_style, p_weight)\n"
16580                 "\n"
16581                 "    This function is used in example 23. \n"
16582                 "\n"
16583                 "\n"
16584                 "\n"
16585                 "SYNOPSIS:\n"
16586                 "\n"
16587                 "plgfont(p_family, p_style, p_weight)\n"
16588                 "\n"
16589                 "ARGUMENTS:\n"
16590                 "\n"
16591                 "    p_family (PLINT *, output) :    Pointer to variable with the current\n"
16592                 "    font family. The available values are given by the PL_FCI_*\n"
16593                 "    constants in plplot.h. Current options are PL_FCI_SANS,\n"
16594                 "    PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
16595                 "    p_family is NULL then the font family is not returned. \n"
16596                 "\n"
16597                 "    p_style (PLINT *, output) :    Pointer to variable with the current\n"
16598                 "    font style. The available values are given by the PL_FCI_*\n"
16599                 "    constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
16600                 "    PL_FCI_ITALIC  and PL_FCI_OBLIQUE. If p_style is NULL then the\n"
16601                 "    font style is not returned. \n"
16602                 "\n"
16603                 "    p_weight (PLINT *, output) :    Pointer to variable with the current\n"
16604                 "    font weight. The available values are given by the PL_FCI_*\n"
16605                 "    constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
16606                 "    PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
16607                 "    returned. \n"
16608                 "\n"
16609                 ""},
16610          { (char *)"plglevel", _wrap_plglevel, METH_VARARGS, (char *)"\n"
16611                 "Get the (current) run level \n"
16612                 "\n"
16613                 "DESCRIPTION:\n"
16614                 "\n"
16615                 "    Get the (current) run level. Valid settings are: 0,  uninitialized \n"
16616                 "           1,  initialized \n"
16617                 "           2,  viewport defined \n"
16618                 "           3,  world coordinates defined \n"
16619                 "\n"
16620                 "\n"
16621                 "    Redacted form: plglevel(p_level)\n"
16622                 "\n"
16623                 "    This function is used in example 31. \n"
16624                 "\n"
16625                 "\n"
16626                 "\n"
16627                 "SYNOPSIS:\n"
16628                 "\n"
16629                 "plglevel(p_level)\n"
16630                 "\n"
16631                 "ARGUMENTS:\n"
16632                 "\n"
16633                 "    p_level (PLINT *, output) :    Pointer to the run level. \n"
16634                 "\n"
16635                 ""},
16636          { (char *)"plgpage", _wrap_plgpage, METH_VARARGS, (char *)"\n"
16637                 "Get page parameters \n"
16638                 "\n"
16639                 "DESCRIPTION:\n"
16640                 "\n"
16641                 "    Gets the current page configuration. The length and offset values are\n"
16642                 "    expressed in units that are specific to the current driver. For\n"
16643                 "    instance: screen drivers will usually interpret them as number of\n"
16644                 "    pixels, whereas printer drivers will usually use mm. \n"
16645                 "\n"
16646                 "    Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
16647                 "\n"
16648                 "    This function is used in examples 14 and 31. \n"
16649                 "\n"
16650                 "\n"
16651                 "\n"
16652                 "SYNOPSIS:\n"
16653                 "\n"
16654                 "plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
16655                 "\n"
16656                 "ARGUMENTS:\n"
16657                 "\n"
16658                 "    p_xp (PLFLT *, output) :    Pointer to number of pixels/inch (DPI), x. \n"
16659                 "\n"
16660                 "    p_yp (PLFLT *, output) :    Pointer to number of pixels/inch (DPI) in\n"
16661                 "    y. \n"
16662                 "\n"
16663                 "    p_xleng (PLINT *, output) :    Pointer to x page length value. \n"
16664                 "\n"
16665                 "    p_yleng (PLINT *, output) :    Pointer to y page length value. \n"
16666                 "\n"
16667                 "    p_xoff (PLINT *, output) :      Pointer to x page offset. \n"
16668                 "\n"
16669                 "    p_yoff (PLINT *, output) :      Pointer to y page offset. \n"
16670                 "\n"
16671                 ""},
16672          { (char *)"plgra", _wrap_plgra, METH_VARARGS, (char *)"\n"
16673                 "Switch to graphics screen \n"
16674                 "\n"
16675                 "DESCRIPTION:\n"
16676                 "\n"
16677                 "    Sets an interactive device to graphics mode, used in conjunction with\n"
16678                 "    pltext to allow graphics and text to be interspersed.  On a device\n"
16679                 "    which supports separate text and graphics windows, this command causes\n"
16680                 "    control to be switched to the graphics window.  If already in graphics\n"
16681                 "    mode, this command is ignored.  It is also ignored on devices which\n"
16682                 "    only support a single window or use a different method for shifting\n"
16683                 "    focus.  See also pltext. \n"
16684                 "\n"
16685                 "    Redacted form: plgra()\n"
16686                 "\n"
16687                 "    This function is used in example 1. \n"
16688                 "\n"
16689                 "\n"
16690                 "\n"
16691                 "SYNOPSIS:\n"
16692                 "\n"
16693                 "plgra()\n"
16694                 "\n"
16695                 ""},
16696          { (char *)"plgriddata", _wrap_plgriddata, METH_VARARGS, (char *)"\n"
16697                 "Grid data from irregularly sampled data \n"
16698                 "\n"
16699                 "DESCRIPTION:\n"
16700                 "\n"
16701                 "    Real world data is frequently irregularly sampled, but all PLplot 3D\n"
16702                 "    plots require data placed in a uniform grid. This function takes\n"
16703                 "    irregularly sampled data from three input arrays x[npts], y[npts], and\n"
16704                 "    z[npts], reads the desired grid location from input arrays xg[nptsx]\n"
16705                 "    and yg[nptsy], and returns the gridded data into output array\n"
16706                 "    zg[nptsx][nptsy].  The algorithm used to grid the data is specified\n"
16707                 "    with the argument type which can have one parameter specified in\n"
16708                 "    argument data. \n"
16709                 "\n"
16710                 "    Redacted form:  General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
16711                 "           Perl/PDL: Not available? \n"
16712                 "           Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
16713                 "\n"
16714                 "\n"
16715                 "    This function is used in example 21. \n"
16716                 "\n"
16717                 "\n"
16718                 "\n"
16719                 "SYNOPSIS:\n"
16720                 "\n"
16721                 "plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
16722                 "\n"
16723                 "ARGUMENTS:\n"
16724                 "\n"
16725                 "    x (const PLFLT *, input) :      The input x array. \n"
16726                 "\n"
16727                 "    y (const PLFLT *, input) :      The input y array. \n"
16728                 "\n"
16729                 "    z (const PLFLT *, input) :      The input z array. Each triple x[i],\n"
16730                 "    y[i], z[i] represents one data sample coordinate. \n"
16731                 "\n"
16732                 "    npts (PLINT, input) :    The number of data samples in the x, y and z\n"
16733                 "    arrays. \n"
16734                 "\n"
16735                 "    xg (const PLFLT *, input) :    The input array that specifies the grid\n"
16736                 "    spacing in the x direction. Usually xg has nptsx equally spaced\n"
16737                 "    values from the minimum to the maximum values of the x input\n"
16738                 "    array. \n"
16739                 "\n"
16740                 "    nptsx (PLINT, input) :    The number of points in the xg array. \n"
16741                 "\n"
16742                 "    yg (const PLFLT *, input) :    The input array that specifies the grid\n"
16743                 "    spacing in the y direction. Similar to the xg parameter. \n"
16744                 "\n"
16745                 "    nptsy (PLINT, input) :    The number of points in the yg array. \n"
16746                 "\n"
16747                 "    zg (PLFLT **, output) :    The output array, where data lies in the\n"
16748                 "    regular grid specified by xg and yg. the zg array must exist or be\n"
16749                 "    allocated by the user prior to the call, and must have dimension\n"
16750                 "    zg[nptsx][nptsy]. \n"
16751                 "\n"
16752                 "    type (PLINT, input) :    The type of gridding algorithm to use, which\n"
16753                 "    can be: GRID_CSA: Bivariate Cubic Spline approximation \n"
16754                 "        GRID_DTLI: Delaunay Triangulation Linear Interpolation \n"
16755                 "        GRID_NNI: Natural Neighbors Interpolation \n"
16756                 "        GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted \n"
16757                 "        GRID_NNLI: Nearest Neighbors Linear Interpolation \n"
16758                 "        GRID_NNAIDW:  Nearest Neighbors Around Inverse Distance\n"
16759                 "        Weighted \n"
16760                 "    For details of the algorithms read the source file plgridd.c. \n"
16761                 "\n"
16762                 "    data (PLFLT, input) :    Some gridding algorithms require extra data,\n"
16763                 "    which can be specified through this argument. Currently, for\n"
16764                 "    algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
16765                 "    use, the lower the value, the noisier (more local) the\n"
16766                 "    approximation is. \n"
16767                 "        GRID_NNLI, data specifies what a thin triangle is, in the\n"
16768                 "        range [1. .. 2.]. High values enable the usage of very thin\n"
16769                 "        triangles for interpolation, possibly resulting in error in\n"
16770                 "        the approximation. \n"
16771                 "        GRID_NNI, only weights greater than data will be accepted. If\n"
16772                 "        0, all weights will be accepted. \n"
16773                 "\n"
16774                 ""},
16775          { (char *)"plgspa", _wrap_plgspa, METH_VARARGS, (char *)"\n"
16776                 "Get current subpage parameters \n"
16777                 "\n"
16778                 "DESCRIPTION:\n"
16779                 "\n"
16780                 "    Gets the size of the current subpage in millimeters measured from the\n"
16781                 "    bottom left hand corner of the output device page or screen.  Can be\n"
16782                 "    used in conjunction with plsvpa for setting the size of a viewport in\n"
16783                 "    absolute coordinates (millimeters). \n"
16784                 "\n"
16785                 "    Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
16786                 "\n"
16787                 "    This function is used in example 23. \n"
16788                 "\n"
16789                 "\n"
16790                 "\n"
16791                 "SYNOPSIS:\n"
16792                 "\n"
16793                 "plgspa(xmin, xmax, ymin, ymax)\n"
16794                 "\n"
16795                 "ARGUMENTS:\n"
16796                 "\n"
16797                 "    xmin (PLFLT *, output) :    Pointer to variable with position of left\n"
16798                 "    hand edge of subpage in millimeters. \n"
16799                 "\n"
16800                 "    xmax (PLFLT *, output) :    Pointer to variable with position of right\n"
16801                 "    hand edge of subpage in millimeters. \n"
16802                 "\n"
16803                 "    ymin (PLFLT *, output) :    Pointer to variable with position of\n"
16804                 "    bottom edge of subpage in millimeters. \n"
16805                 "\n"
16806                 "    ymax (PLFLT *, output) :    Pointer to variable with position of top\n"
16807                 "    edge of subpage in millimeters. \n"
16808                 "\n"
16809                 ""},
16810          { (char *)"plgstrm", _wrap_plgstrm, METH_VARARGS, (char *)"\n"
16811                 "Get current stream number \n"
16812                 "\n"
16813                 "DESCRIPTION:\n"
16814                 "\n"
16815                 "    Gets the number of the current output stream. See also plsstrm. \n"
16816                 "\n"
16817                 "    Redacted form: plgstrm(p_strm)\n"
16818                 "\n"
16819                 "    This function is used in example 1,20. \n"
16820                 "\n"
16821                 "\n"
16822                 "\n"
16823                 "SYNOPSIS:\n"
16824                 "\n"
16825                 "plgstrm(p_strm)\n"
16826                 "\n"
16827                 "ARGUMENTS:\n"
16828                 "\n"
16829                 "    p_strm (PLINT *, output) :      Pointer to current stream value. \n"
16830                 "\n"
16831                 ""},
16832          { (char *)"plgver", _wrap_plgver, METH_VARARGS, (char *)"\n"
16833                 "Get the current library version number \n"
16834                 "\n"
16835                 "DESCRIPTION:\n"
16836                 "\n"
16837                 "    Get the current library version number.  Note: you must have allocated\n"
16838                 "    space for this (80 characters is safe). \n"
16839                 "\n"
16840                 "    Redacted form: plgver(p_ver)\n"
16841                 "\n"
16842                 "    This function is used in example 1. \n"
16843                 "\n"
16844                 "\n"
16845                 "\n"
16846                 "SYNOPSIS:\n"
16847                 "\n"
16848                 "plgver(p_ver)\n"
16849                 "\n"
16850                 "ARGUMENTS:\n"
16851                 "\n"
16852                 "    p_ver (char *, output) :    Pointer to the current library version\n"
16853                 "    number. \n"
16854                 "\n"
16855                 ""},
16856          { (char *)"plgvpd", _wrap_plgvpd, METH_VARARGS, (char *)"\n"
16857                 "Get viewport limits in normalized device coordinates \n"
16858                 "\n"
16859                 "DESCRIPTION:\n"
16860                 "\n"
16861                 "    Get viewport limits in normalized device coordinates. \n"
16862                 "\n"
16863                 "    Redacted form:  General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16864                 "           Perl/PDL: Not available? \n"
16865                 "\n"
16866                 "\n"
16867                 "    This function is used in example 31. \n"
16868                 "\n"
16869                 "\n"
16870                 "\n"
16871                 "SYNOPSIS:\n"
16872                 "\n"
16873                 "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16874                 "\n"
16875                 "ARGUMENTS:\n"
16876                 "\n"
16877                 "    p_xmin (PLFLT *, output) :      Lower viewport limit of the normalized\n"
16878                 "    device coordinate in x. \n"
16879                 "\n"
16880                 "    p_xmax (PLFLT *, output) :      Upper viewport limit of the normalized\n"
16881                 "    device coordinate in x. \n"
16882                 "\n"
16883                 "    p_ymin (PLFLT *, output) :      Lower viewport limit of the normalized\n"
16884                 "    device coordinate in y. \n"
16885                 "\n"
16886                 "    p_ymax (PLFLT *, output) :      Upper viewport limit of the normalized\n"
16887                 "    device coordinate in y. \n"
16888                 "\n"
16889                 ""},
16890          { (char *)"plgvpw", _wrap_plgvpw, METH_VARARGS, (char *)"\n"
16891                 "Get viewport limits in world coordinates \n"
16892                 "\n"
16893                 "DESCRIPTION:\n"
16894                 "\n"
16895                 "    Get viewport limits in world coordinates. \n"
16896                 "\n"
16897                 "    Redacted form:  General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16898                 "           Perl/PDL: Not available? \n"
16899                 "\n"
16900                 "\n"
16901                 "    This function is used in example 31. \n"
16902                 "\n"
16903                 "\n"
16904                 "\n"
16905                 "SYNOPSIS:\n"
16906                 "\n"
16907                 "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16908                 "\n"
16909                 "ARGUMENTS:\n"
16910                 "\n"
16911                 "    p_xmin (PLFLT *, output) :      Lower viewport limit of the world\n"
16912                 "    coordinate in x. \n"
16913                 "\n"
16914                 "    p_xmax (PLFLT *, output) :      Upper viewport limit of the world\n"
16915                 "    coordinate in x. \n"
16916                 "\n"
16917                 "    p_ymin (PLFLT *, output) :      Lower viewport limit of the world\n"
16918                 "    coordinate in y. \n"
16919                 "\n"
16920                 "    p_ymax (PLFLT *, output) :      Upper viewport limit of the world\n"
16921                 "    coordinate in y. \n"
16922                 "\n"
16923                 ""},
16924          { (char *)"plgxax", _wrap_plgxax, METH_VARARGS, (char *)"\n"
16925                 "Get x axis parameters \n"
16926                 "\n"
16927                 "DESCRIPTION:\n"
16928                 "\n"
16929                 "    Returns current values of the p_digmax and p_digits flags for the x\n"
16930                 "    axis.  p_digits is updated after the plot is drawn, so this routine\n"
16931                 "    should only be called after the call to plbox (or plbox3) is complete.\n"
16932                 "     See the PLplot documentation for more information. \n"
16933                 "\n"
16934                 "    Redacted form: plgxax(p_digmax, p_digits)\n"
16935                 "\n"
16936                 "    This function is used in example 31. \n"
16937                 "\n"
16938                 "\n"
16939                 "\n"
16940                 "SYNOPSIS:\n"
16941                 "\n"
16942                 "plgxax(p_digmax, p_digits)\n"
16943                 "\n"
16944                 "ARGUMENTS:\n"
16945                 "\n"
16946                 "    p_digmax (PLINT *, output) :    Pointer to variable with the maximum\n"
16947                 "    number of digits for the x axis.  If nonzero, the printed label\n"
16948                 "    has been switched to a floating point representation when the\n"
16949                 "    number of digits exceeds p_digmax. \n"
16950                 "\n"
16951                 "    p_digits (PLINT *, output) :    Pointer to variable with the actual\n"
16952                 "    number of digits for the numeric labels (x axis) from the last\n"
16953                 "    plot. \n"
16954                 "\n"
16955                 ""},
16956          { (char *)"plgyax", _wrap_plgyax, METH_VARARGS, (char *)"\n"
16957                 "Get y axis parameters \n"
16958                 "\n"
16959                 "DESCRIPTION:\n"
16960                 "\n"
16961                 "    Identical to plgxax, except that arguments are flags for y axis. See\n"
16962                 "    the description of plgxax for more detail. \n"
16963                 "\n"
16964                 "    Redacted form: plgyax(p_digmax, p_digits)\n"
16965                 "\n"
16966                 "    This function is used in example 31. \n"
16967                 "\n"
16968                 "\n"
16969                 "\n"
16970                 "SYNOPSIS:\n"
16971                 "\n"
16972                 "plgyax(p_digmax, p_digits)\n"
16973                 "\n"
16974                 "ARGUMENTS:\n"
16975                 "\n"
16976                 "    p_digmax (PLINT *, output) :    Pointer to variable with the maximum\n"
16977                 "    number of digits for the y axis.  If nonzero, the printed label\n"
16978                 "    has been switched to a floating point representation when the\n"
16979                 "    number of digits exceeds p_digmax. \n"
16980                 "\n"
16981                 "    p_digits (PLINT *, output) :    Pointer to variable with the actual\n"
16982                 "    number of digits for the numeric labels (y axis) from the last\n"
16983                 "    plot. \n"
16984                 "\n"
16985                 ""},
16986          { (char *)"plgzax", _wrap_plgzax, METH_VARARGS, (char *)"\n"
16987                 "Get z axis parameters \n"
16988                 "\n"
16989                 "DESCRIPTION:\n"
16990                 "\n"
16991                 "    Identical to plgxax, except that arguments are flags for z axis. See\n"
16992                 "    the description of plgxax for more detail. \n"
16993                 "\n"
16994                 "    Redacted form: plgzax(p_digmax, p_digits)\n"
16995                 "\n"
16996                 "    This function is used in example 31. \n"
16997                 "\n"
16998                 "\n"
16999                 "\n"
17000                 "SYNOPSIS:\n"
17001                 "\n"
17002                 "plgzax(p_digmax, p_digits)\n"
17003                 "\n"
17004                 "ARGUMENTS:\n"
17005                 "\n"
17006                 "    p_digmax (PLINT *, output) :    Pointer to variable with the maximum\n"
17007                 "    number of digits for the z axis.  If nonzero, the printed label\n"
17008                 "    has been switched to a floating point representation when the\n"
17009                 "    number of digits exceeds p_digmax. \n"
17010                 "\n"
17011                 "    p_digits (PLINT *, output) :    Pointer to variable with the actual\n"
17012                 "    number of digits for the numeric labels (z axis) from the last\n"
17013                 "    plot. \n"
17014                 "\n"
17015                 ""},
17016          { (char *)"plhist", _wrap_plhist, METH_VARARGS, (char *)"\n"
17017                 "Plot a histogram from unbinned data \n"
17018                 "\n"
17019                 "DESCRIPTION:\n"
17020                 "\n"
17021                 "    Plots a histogram from n data points stored in the array data.  This\n"
17022                 "    routine bins the data into nbin bins equally spaced between datmin and\n"
17023                 "    datmax, and calls plbin to draw the resulting histogram.  Parameter\n"
17024                 "    opt allows, among other things, the histogram either to be plotted in\n"
17025                 "    an existing window or causes plhist to call plenv with suitable limits\n"
17026                 "    before plotting the histogram. \n"
17027                 "\n"
17028                 "    Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
17029                 "\n"
17030                 "    This function is used in example 5. \n"
17031                 "\n"
17032                 "\n"
17033                 "\n"
17034                 "SYNOPSIS:\n"
17035                 "\n"
17036                 "plhist(n, data, datmin, datmax, nbin, opt)\n"
17037                 "\n"
17038                 "ARGUMENTS:\n"
17039                 "\n"
17040                 "    n (PLINT, input) :      Number of data points. \n"
17041                 "\n"
17042                 "    data (const PLFLT *, input) :    Pointer to array with values of the n\n"
17043                 "    data points. \n"
17044                 "\n"
17045                 "    datmin (PLFLT, input) :    Left-hand edge of lowest-valued bin. \n"
17046                 "\n"
17047                 "    datmax (PLFLT, input) :    Right-hand edge of highest-valued bin. \n"
17048                 "\n"
17049                 "    nbin (PLINT, input) :    Number of (equal-sized) bins into which to\n"
17050                 "    divide the interval xmin to xmax. \n"
17051                 "\n"
17052                 "    opt (PLINT, input) :    Is a combination of several flags:\n"
17053                 "    opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
17054                 "    the histogram data, the outer bins are expanded to fill up the\n"
17055                 "    entire x-axis, data outside the given extremes are assigned to the\n"
17056                 "    outer bins and bins of zero height are simply drawn. \n"
17057                 "        opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
17058                 "        to fit the histogram data, without this flag, plenv is called\n"
17059                 "        to set the world coordinates. \n"
17060                 "        opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
17061                 "        extremes are not taken into account. This option should\n"
17062                 "        probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
17063                 "        properly present the data. \n"
17064                 "        opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
17065                 "        size as the ones inside. \n"
17066                 "        opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
17067                 "        (there is a gap for such bins). \n"
17068                 "\n"
17069                 ""},
17070          { (char *)"plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, (char *)"\n"
17071                 "Convert HLS color to RGB \n"
17072                 "\n"
17073                 "DESCRIPTION:\n"
17074                 "\n"
17075                 "    Convert HLS color coordinates to RGB. \n"
17076                 "\n"
17077                 "    Redacted form:  General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17078                 "           Perl/PDL: Not available? Implemented as plhls? \n"
17079                 "\n"
17080                 "\n"
17081                 "    This function is used in example 2. \n"
17082                 "\n"
17083                 "\n"
17084                 "\n"
17085                 "SYNOPSIS:\n"
17086                 "\n"
17087                 "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17088                 "\n"
17089                 "ARGUMENTS:\n"
17090                 "\n"
17091                 "    h (PLFLT, input) :      Hue, in degrees on the colour cone (0.0-360.0) \n"
17092                 "\n"
17093                 "    l (PLFLT, input) :      Lightness, expressed as a fraction of the axis\n"
17094                 "    of the colour cone (0.0-1.0) \n"
17095                 "\n"
17096                 "    s (PLFLT, input) :      Saturation, expressed as a fraction of the\n"
17097                 "    radius of the colour cone (0.0-1.0) \n"
17098                 "\n"
17099                 "    p_r (PLFLT *, output) :    Pointer to red intensity (0.0-1.0) of the\n"
17100                 "    colour \n"
17101                 "\n"
17102                 "    p_g (PLFLT *, output) :    Pointer to green intensity (0.0-1.0) of the\n"
17103                 "    colour \n"
17104                 "\n"
17105                 "    p_b (PLFLT *, output) :    Pointer to blue intensity (0.0-1.0) of the\n"
17106                 "    colour \n"
17107                 "\n"
17108                 ""},
17109          { (char *)"plinit", _wrap_plinit, METH_VARARGS, (char *)"\n"
17110                 "Initialize PLplot \n"
17111                 "\n"
17112                 "DESCRIPTION:\n"
17113                 "\n"
17114                 "    Initializing the plotting package. The program prompts for the device\n"
17115                 "    keyword or number of the desired output device.  Hitting a RETURN in\n"
17116                 "    response to the prompt is the same as selecting the first device. \n"
17117                 "    plinit will issue no prompt if either the device was specified\n"
17118                 "    previously (via command line flag, the plsetopt function, or the\n"
17119                 "    plsdev function), or if only one device is enabled when PLplot is\n"
17120                 "    installed. If subpages have been specified, the output device is\n"
17121                 "    divided into nx by ny subpages, each of which may be used\n"
17122                 "    independently.  If plinit is called again during a program, the\n"
17123                 "    previously opened file will be closed.  The subroutine pladv is used\n"
17124                 "    to advance from one subpage to the next. \n"
17125                 "\n"
17126                 "    Redacted form: plinit()\n"
17127                 "\n"
17128                 "    This function is used in all of the examples. \n"
17129                 "\n"
17130                 "\n"
17131                 "\n"
17132                 "SYNOPSIS:\n"
17133                 "\n"
17134                 "plinit()\n"
17135                 "\n"
17136                 ""},
17137          { (char *)"pljoin", _wrap_pljoin, METH_VARARGS, (char *)"\n"
17138                 "Draw a line between two points \n"
17139                 "\n"
17140                 "DESCRIPTION:\n"
17141                 "\n"
17142                 "    Joins the point (\n"
17143                 "    x1, \n"
17144                 "    y1) to (\n"
17145                 "    x2, \n"
17146                 "    y2). \n"
17147                 "\n"
17148                 "    Redacted form: pljoin(x1,y1,x2,y2)\n"
17149                 "\n"
17150                 "    This function is used in examples 3,14. \n"
17151                 "\n"
17152                 "\n"
17153                 "\n"
17154                 "SYNOPSIS:\n"
17155                 "\n"
17156                 "pljoin(x1, y1, x2, y2)\n"
17157                 "\n"
17158                 "ARGUMENTS:\n"
17159                 "\n"
17160                 "    x1 (PLFLT, input) :    x coordinate of first point. \n"
17161                 "\n"
17162                 "    y1 (PLFLT, input) :    y coordinate of first point. \n"
17163                 "\n"
17164                 "    x2 (PLFLT, input) :    x coordinate of second point. \n"
17165                 "\n"
17166                 "    y2 (PLFLT, input) :    y coordinate of second point. \n"
17167                 "\n"
17168                 ""},
17169          { (char *)"pllab", _wrap_pllab, METH_VARARGS, (char *)"\n"
17170                 "Simple routine to write labels \n"
17171                 "\n"
17172                 "DESCRIPTION:\n"
17173                 "\n"
17174                 "    Routine for writing simple labels. Use plmtex for more complex labels. \n"
17175                 "\n"
17176                 "    Redacted form: pllab(xlabel, ylabel, tlabel)\n"
17177                 "\n"
17178                 "    This function is used in examples 1,5,9,12,14-16,20-22,29. \n"
17179                 "\n"
17180                 "\n"
17181                 "\n"
17182                 "SYNOPSIS:\n"
17183                 "\n"
17184                 "pllab(xlabel, ylabel, tlabel)\n"
17185                 "\n"
17186                 "ARGUMENTS:\n"
17187                 "\n"
17188                 "    xlabel (const char *, input) :    Label for horizontal axis. \n"
17189                 "\n"
17190                 "    ylabel (const char *, input) :    Label for vertical axis. \n"
17191                 "\n"
17192                 "    tlabel (const char *, input) :    Title of graph. \n"
17193                 "\n"
17194                 ""},
17195          { (char *)"pllegend", _wrap_pllegend, METH_VARARGS, (char *)"\n"
17196                 "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols \n"
17197                 "\n"
17198                 "DESCRIPTION:\n"
17199                 "\n"
17200                 "    Routine for creating a discrete plot legend with a plotted filled box,\n"
17201                 "    line, and/or line of symbols for each annotated legend entry.  (See\n"
17202                 "    plcolorbar for similar functionality for creating continuous color\n"
17203                 "    bars.)  The arguments of pllegend provide control over the location\n"
17204                 "    and size of the legend as well as the location and characteristics of\n"
17205                 "    the elements (most of which are optional) within that legend.  The\n"
17206                 "    resulting legend is clipped at the boundaries of the current subpage. \n"
17207                 "    (N.B. the adopted coordinate system used for some of the parameters is\n"
17208                 "    defined in the documentation of the position parameter.) \n"
17209                 "\n"
17210                 "    Redacted form: pllegend(p_legend_width, p_legend_height,  opt,\n"
17211                 "    position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
17212                 "    ncolumn, opt_array,  text_offset, text_scale, text_spacing,\n"
17213                 "    test_justification, text_colors, text,  box_colors, box_patterns,\n"
17214                 "    box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
17215                 "    symbol_colors, symbol_scales,  symbol_numbers, symbols)\n"
17216                 "\n"
17217                 "    This function is used in examples 4, 26, and 33. \n"
17218                 "\n"
17219                 "\n"
17220                 "\n"
17221                 "SYNOPSIS:\n"
17222                 "\n"
17223                 "pllegend(p_legend_width, p_legend_height, opt, position, x, y, plot_width, bg_color, bb_color, bb_style, nrow, ncolumn, nlegend, opt_array, text_offset, text_scale, text_spacing, test_justification, text_colors, text, box_colors, box_patterns, box_scales, box_line_widths, line_colors, line_styles, line_widths, symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
17224                 "\n"
17225                 "ARGUMENTS:\n"
17226                 "\n"
17227                 "    p_legend_width (PLFLT *, output) :      Pointer to a location which\n"
17228                 "    contains (after the call) the legend width in adopted coordinates.\n"
17229                 "    This quantity is calculated from plot_width, text_offset, ncolumn\n"
17230                 "    (possibly modified inside the routine depending on nlegend and\n"
17231                 "    nrow), and the length (calculated internally) of the longest text\n"
17232                 "    string. \n"
17233                 "\n"
17234                 "    p_legend_height (PLFLT *, output) :    Pointer to a location which\n"
17235                 "    contains (after the call) the legend height in adopted\n"
17236                 "    coordinates. This quantity is calculated from text_scale,\n"
17237                 "    text_spacing, and nrow (possibly modified inside the routine\n"
17238                 "    depending on nlegend and nrow). \n"
17239                 "\n"
17240                 "    opt (PLINT, input) :    opt contains bits controlling the overall\n"
17241                 "    legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
17242                 "    on the left of the legend and the plotted area on the right.\n"
17243                 "    Otherwise, put the text area on the right of the legend and the\n"
17244                 "    plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
17245                 "    plot a (semi-transparent) background for the legend. If the\n"
17246                 "    PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17247                 "    legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
17248                 "    possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
17249                 "    plot the resulting array of legend entries in row-major order.\n"
17250                 "    Otherwise, plot the legend entries in column-major order. \n"
17251                 "\n"
17252                 "    position (PLINT, input) :     position contains bits which control the\n"
17253                 "    overall position of the legend and the definition of the adopted\n"
17254                 "    coordinates used for positions just like what is done for the\n"
17255                 "    position argument for plcolorbar. However, note that the defaults\n"
17256                 "    for the position bits (see below) are different than the\n"
17257                 "    plcolorbar case.  The combination of the PL_POSITION_LEFT,\n"
17258                 "    PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17259                 "    PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17260                 "    the 16 possible standard positions (the 4 corners and centers of\n"
17261                 "    the 4 sides for both the inside and outside cases) of the legend\n"
17262                 "    relative to the adopted coordinate system. The corner positions\n"
17263                 "    are specified by the appropriate combination of two of the\n"
17264                 "    PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17265                 "    PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17266                 "    value of one of those bits.  The adopted coordinates are\n"
17267                 "    normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17268                 "    set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17269                 "    bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17270                 "    PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17271                 "    then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n"
17272                 "    If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n"
17273                 "    use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
17274                 "    PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT. \n"
17275                 "\n"
17276                 "    x (PLFLT, input) :      X offset of the legend position in adopted\n"
17277                 "    coordinates from the specified standard position of the legend.\n"
17278                 "    For positive x, the direction of motion away from the standard\n"
17279                 "    position is inward/outward from the standard corner positions or\n"
17280                 "    standard left or right positions if the\n"
17281                 "    PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
17282                 "    For the standard top or bottom positions, the direction of motion\n"
17283                 "    is toward positive X. \n"
17284                 "\n"
17285                 "    y (PLFLT, input) :      Y offset of the legend position in adopted\n"
17286                 "    coordinates from the specified standard position of the legend.\n"
17287                 "    For positive y, the direction of motion away from the standard\n"
17288                 "    position is inward/outward from the standard corner positions or\n"
17289                 "    standard top or bottom positions if the\n"
17290                 "    PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
17291                 "    For the standard left or right positions, the  direction of motion\n"
17292                 "    is toward positive Y. \n"
17293                 "\n"
17294                 "    plot_width (PLFLT, input) :    Horizontal width in adopted coordinates\n"
17295                 "    of the plot area (where the colored boxes, lines, and/or lines of\n"
17296                 "    symbols are drawn) of the legend. \n"
17297                 "\n"
17298                 "    bg_color (PLINT, input) :     The cmap0 color of the background for the\n"
17299                 "    legend (PL_LEGEND_BACKGROUND). \n"
17300                 "\n"
17301                 "    bb_color (PLINT, input) :     The cmap0 color of the bounding-box line\n"
17302                 "    for the legend (PL_LEGEND_BOUNDING_BOX). \n"
17303                 "\n"
17304                 "    bb_style (PLINT, input) :     The pllsty style number for the\n"
17305                 "    bounding-box line for the legend (PL_LEGEND_BACKGROUND). \n"
17306                 "\n"
17307                 "    nrow (PLINT, input) :    The cmap0 index of the background color for\n"
17308                 "    the legend (PL_LEGEND_BACKGROUND). \n"
17309                 "\n"
17310                 "    ncolumn (PLINT, input) :    The cmap0 index of the background color\n"
17311                 "    for the legend (PL_LEGEND_BACKGROUND). \n"
17312                 "\n"
17313                 "    nlegend (PLINT, input) :    Number of legend entries.  N.B.  The total\n"
17314                 "    vertical height of the legend in adopted coordinates is calculated\n"
17315                 "    internally from nlegend, text_scale (see below), and text_spacing\n"
17316                 "    (see below). \n"
17317                 "\n"
17318                 "    opt_array (const PLINT *, input) :      Array of nlegend values of\n"
17319                 "    options to control each individual plotted area corresponding to a\n"
17320                 "    legend entry.  If the \n"
17321                 "    PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
17322                 "    area.  If the \n"
17323                 "    PL_LEGEND_COLOR_BOX, \n"
17324                 "    PL_LEGEND_LINE, and/or \n"
17325                 "    PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
17326                 "    entry is plotted with a colored box; a line; and/or a line of\n"
17327                 "    symbols. \n"
17328                 "\n"
17329                 "    text_offset (PLFLT, input) :    Offset of the text area from the plot\n"
17330                 "    area in units of character width.  N.B.  The total horizontal\n"
17331                 "    width of the legend in adopted coordinates is calculated\n"
17332                 "    internally from \n"
17333                 "    plot_width (see above), \n"
17334                 "    text_offset, and length (calculated internally) of the longest text\n"
17335                 "    string. \n"
17336                 "\n"
17337                 "    text_scale (PLFLT, input) :    Character height scale for text\n"
17338                 "    annotations.  N.B.  The total vertical height of the legend in\n"
17339                 "    adopted coordinates is calculated internally from \n"
17340                 "    nlegend (see above), \n"
17341                 "    text_scale, and \n"
17342                 "    text_spacing (see below). \n"
17343                 "\n"
17344                 "    text_spacing (PLFLT, input) :    Vertical spacing in units of the\n"
17345                 "    character height from one legend entry to the next.  N.B.  The\n"
17346                 "    total vertical height of the legend in adopted coordinates is\n"
17347                 "    calculated internally from \n"
17348                 "    nlegend (see above), \n"
17349                 "    text_scale (see above), and \n"
17350                 "    text_spacing. \n"
17351                 "\n"
17352                 "    text_justification (PLFLT, input) :    Justification parameter used\n"
17353                 "    for text justification.  The most common values of\n"
17354                 "    text_justification are 0., 0.5, or 1. corresponding to a text that\n"
17355                 "    is left justified, centred, or right justified within the text\n"
17356                 "    area, but other values are allowed as well. \n"
17357                 "\n"
17358                 "    text_colors (const PLINT *, input) :    Array of nlegend cmap0 text\n"
17359                 "    colors. \n"
17360                 "\n"
17361                 "    text (const char * const *, input) :    Array of nlegend text string\n"
17362                 "    annotations. \n"
17363                 "\n"
17364                 "    box_colors (const PLINT *, input) :    Array of nlegend cmap0 colors\n"
17365                 "    for the discrete colored boxes (\n"
17366                 "    PL_LEGEND_COLOR_BOX). \n"
17367                 "\n"
17368                 "    box_patterns (const PLINT *, input) :    Array of nlegend patterns\n"
17369                 "    (plpsty indices) for the discrete colored boxes (\n"
17370                 "    PL_LEGEND_COLOR_BOX). \n"
17371                 "\n"
17372                 "    box_scales (const PLFLT *, input) :    Array of nlegend scales (units\n"
17373                 "    of fraction of character height) for the height of the discrete\n"
17374                 "    colored boxes  (\n"
17375                 "    PL_LEGEND_COLOR_BOX). \n"
17376                 "\n"
17377                 "    box_line_widths (const PLFLT *, input) :    Array of nlegend line\n"
17378                 "    widths for the patterns specified by box_patterns (\n"
17379                 "    PL_LEGEND_COLOR_BOX). \n"
17380                 "\n"
17381                 "    line_colors (const PLINT *, input) :    Array of nlegend cmap0 line\n"
17382                 "    colors (\n"
17383                 "    PL_LEGEND_LINE). \n"
17384                 "\n"
17385                 "    line_styles (const PLINT *, input) :    Array of nlegend line styles\n"
17386                 "    (plsty indices)  (\n"
17387                 "    PL_LEGEND_LINE). \n"
17388                 "\n"
17389                 "    line_widths (const PLFLT *, input) :    Array of nlegend line widths (\n"
17390                 "    PL_LEGEND_LINE). \n"
17391                 "\n"
17392                 "    symbol_colors (const PLINT *, input) :    Array of nlegend cmap0\n"
17393                 "    symbol colors  (\n"
17394                 "    PL_LEGEND_SYMBOL). \n"
17395                 "\n"
17396                 "    symbol_scales (const PLFLT *, input) :    Array of nlegend scale\n"
17397                 "    values for the symbol height  (\n"
17398                 "    PL_LEGEND_SYMBOL). \n"
17399                 "\n"
17400                 "    symbol_numbers (const PLINT *, input) :    Array of nlegend numbers of\n"
17401                 "    symbols to be drawn across the width of the plotted area (\n"
17402                 "    PL_LEGEND_SYMBOL). \n"
17403                 "\n"
17404                 "    symbols (const char * const *, input) :    Array of nlegend symbols\n"
17405                 "    (plpoin indices)  (\n"
17406                 "    PL_LEGEND_SYMBOL). \n"
17407                 "\n"
17408                 ""},
17409          { (char *)"plcolorbar", _wrap_plcolorbar, METH_VARARGS, (char *)"\n"
17410                 "Plot color bar for image, shade or gradient plots \n"
17411                 "\n"
17412                 "DESCRIPTION:\n"
17413                 "\n"
17414                 "    Routine for creating a continuous color bar for image, shade, or\n"
17415                 "    gradient plots. (See pllegend for similar functionality for creating\n"
17416                 "    legends with discrete elements). The arguments of plcolorbar provide\n"
17417                 "    control over the location and size of the color bar as well as the\n"
17418                 "    location and characteristics of the elements (most of which are\n"
17419                 "    optional) within that color bar.  The resulting color bar is clipped\n"
17420                 "    at the boundaries of the current subpage. (N.B. the adopted coordinate\n"
17421                 "    system used for some of the parameters is defined in the documentation\n"
17422                 "    of the position parameter.) \n"
17423                 "\n"
17424                 "    Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height,  opt,\n"
17425                 "    position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n"
17426                 "    low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n"
17427                 "    labels, axis_opts, ticks, sub_ticks, values)\n"
17428                 "\n"
17429                 "    This function is used in examples 16 and 33. \n"
17430                 "\n"
17431                 "\n"
17432                 "\n"
17433                 "SYNOPSIS:\n"
17434                 "\n"
17435                 "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, labels, naxes, axis_opts, ticks, sub_ticks, n_values, values)\n"
17436                 "\n"
17437                 "ARGUMENTS:\n"
17438                 "\n"
17439                 "    p_colorbar_width (PLFLT *, output) :    Pointer to a location which\n"
17440                 "    contains (after the call) the labelled and decorated color bar\n"
17441                 "    width in adopted coordinates. \n"
17442                 "\n"
17443                 "    p_colorbar_height (PLFLT *, output) :    Pointer to a location which\n"
17444                 "    contains (after the call) the labelled and decorated color bar\n"
17445                 "    height in adopted coordinates. \n"
17446                 "\n"
17447                 "    opt (PLINT, input) :    opt contains bits controlling the overall\n"
17448                 "    color bar.  The orientation (direction of the maximum value) of\n"
17449                 "    the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n"
17450                 "    PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM.  If none of these bits are\n"
17451                 "    specified, the default orientation is toward the top if the\n"
17452                 "    colorbar is placed on the left or right of the viewport or toward\n"
17453                 "    the right if the colorbar is placed on the top or bottom of the\n"
17454                 "    viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n"
17455                 "    (semi-transparent) background for the color bar. If the\n"
17456                 "    PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17457                 "    color bar. The type of color bar must be specified with one of\n"
17458                 "    PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n"
17459                 "    more than one of those bits is set only the first one in the above\n"
17460                 "    list is honored. The position of the (optional) label/title can be\n"
17461                 "    specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n"
17462                 "    PL_LABEL_BOTTOM.  If no label position bit is set then no label\n"
17463                 "    will be drawn. If more than one of this list of bits is specified,\n"
17464                 "    only the first one on the list is honored. End-caps for the color\n"
17465                 "    bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n"
17466                 "    If a particular color bar cap option is not specified then no cap\n"
17467                 "    will be drawn for that end. As a special case for\n"
17468                 "    PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n"
17469                 "    specified. If this option is provided then any tick marks and tick\n"
17470                 "    labels will be placed at the breaks between shaded segments. TODO:\n"
17471                 "    This should be expanded to support custom placement of tick marks\n"
17472                 "    and tick labels at custom value locations for any color bar type. \n"
17473                 "\n"
17474                 "    position (PLINT, input) :     position contains bits which control the\n"
17475                 "    overall position of the color bar and the definition of the\n"
17476                 "    adopted coordinates used for positions just like what is done for\n"
17477                 "    the position argument for pllegend. However, note that the\n"
17478                 "    defaults for the position bits (see below) are different than the\n"
17479                 "    pllegend case. The combination of the PL_POSITION_LEFT,\n"
17480                 "    PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17481                 "    PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17482                 "    the 16 possible standard positions (the 4 corners and centers of\n"
17483                 "    the 4 sides for both the inside and outside cases) of the color\n"
17484                 "    bar relative to the adopted coordinate system. The corner\n"
17485                 "    positions are specified by the appropriate combination of two of\n"
17486                 "    the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17487                 "    PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17488                 "    value of one of those bits.  The adopted coordinates are\n"
17489                 "    normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17490                 "    set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17491                 "    bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17492                 "    PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17493                 "    then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n"
17494                 "    PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n"
17495                 "    PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n"
17496                 "    PL_POSITION_VIEWPORT. \n"
17497                 "\n"
17498                 "    x (PLFLT, input) :      X offset of the color bar position in adopted\n"
17499                 "    coordinates from the specified standard position of the color bar.\n"
17500                 "    For positive x, the direction of motion away from the standard\n"
17501                 "    position is inward/outward from the standard corner positions or\n"
17502                 "    standard left or right positions if the\n"
17503                 "    PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
17504                 "    For the standard top or bottom positions, the direction of motion\n"
17505                 "    is toward positive X. \n"
17506                 "\n"
17507                 "    y (PLFLT, input) :      Y offset of the color bar position in adopted\n"
17508                 "    coordinates from the specified standard position of the color bar.\n"
17509                 "    For positive y, the direction of motion away from the standard\n"
17510                 "    position is inward/outward from the standard corner positions or\n"
17511                 "    standard top or bottom positions if the\n"
17512                 "    PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n"
17513                 "    For the standard left or right positions, the direction of motion\n"
17514                 "    is toward positive Y. \n"
17515                 "\n"
17516                 "    x_length (PLFLT, input) :     Length of the body of the color bar in\n"
17517                 "    the X direction in adopted coordinates. \n"
17518                 "\n"
17519                 "    y_length (PLFLT, input) :     Length of the body of the color bar in\n"
17520                 "    the Y direction in adopted coordinates. \n"
17521                 "\n"
17522                 "    bg_color (PLINT, input) :     The cmap0 color of the background for the\n"
17523                 "    color bar (PL_COLORBAR_BACKGROUND). \n"
17524                 "\n"
17525                 "    bb_color (PLINT, input) :     The cmap0 color of the bounding-box line\n"
17526                 "    for the color bar (PL_COLORBAR_BOUNDING_BOX). \n"
17527                 "\n"
17528                 "    bb_style (PLINT, input) :     The pllsty style number for the\n"
17529                 "    bounding-box line for the color bar (PL_COLORBAR_BACKGROUND). \n"
17530                 "\n"
17531                 "    low_cap_color (PLFLT, input) :    The cmap1 color of the low-end color\n"
17532                 "    bar cap, if it is drawn (PL_COLORBAR_CAP_LOW). \n"
17533                 "\n"
17534                 "    high_cap_color (PLFLT, input) :    The cmap1 color of the high-end\n"
17535                 "    color bar cap, if it is drawn  (PL_COLORBAR_CAP_HIGH). \n"
17536                 "\n"
17537                 "    cont_color (PLINT, input) :    The cmap0 contour color for\n"
17538                 "    PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n"
17539                 "    it will be interpreted according to the design of plshades. \n"
17540                 "\n"
17541                 "    cont_width (PLFLT, input) :    Contour width for PL_COLORBAR_SHADE\n"
17542                 "    plots. This is passed directly to plshades, so it will be\n"
17543                 "    interpreted according to the design of plshades. \n"
17544                 "\n"
17545                 "    n_labels (PLINT, input) :     Number of labels to place around the\n"
17546                 "    color bar. \n"
17547                 "\n"
17548                 "    label_opts (const PLINT *, input) :    Options for each of \n"
17549                 "    n_labels labels. \n"
17550                 "\n"
17551                 "    labels (const char * const *, input) :    n_labels text labels for the\n"
17552                 "    color bar. No label is drawn if no label position is specified\n"
17553                 "    with one of the PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n"
17554                 "    PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n"
17555                 "    corresponding label_opts field. \n"
17556                 "\n"
17557                 "    n_axes (PLINT, input) :    Number of axis definitions provided. This\n"
17558                 "    value must be greater than 0. It is typically 1 (numerical axis\n"
17559                 "    labels are provided for one of the long edges of the color bar),\n"
17560                 "    but it can be larger if multiple numerical axis labels for the\n"
17561                 "    long edges of the color bar are desired. \n"
17562                 "\n"
17563                 "    axis_opts (const char * const *, input) :     An array of n_axes axis\n"
17564                 "    options (interpreted as for plbox) for the color bar's axis\n"
17565                 "    definitions. \n"
17566                 "\n"
17567                 "    ticks (const PLFLT *, input) :    An array of n_axes values of the\n"
17568                 "    spacing of the major tick marks (interpreted as for plbox) for the\n"
17569                 "    color bar's axis definitions. \n"
17570                 "\n"
17571                 "    sub_ticks (const PLINT *, input) :      An array of n_axes values of the\n"
17572                 "    number of subticks (interpreted as for plbox) for the color bar's\n"
17573                 "    axis definitions. \n"
17574                 "\n"
17575                 "    n_values (const PLINT *, input) :     An array containing the number of\n"
17576                 "    elements in each of the n_axes rows of the two-dimensional values\n"
17577                 "    array. \n"
17578                 "\n"
17579                 "    values (const PLFLT * const *, input) :    A two-dimensional array\n"
17580                 "    containing the numeric values for the data range represented by\n"
17581                 "    the color bar. For a row index of i_axis (where 0 < i_axis <\n"
17582                 "    n_axes), the number of elements in the row is specified by\n"
17583                 "    n_values[i_axis]. For PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT\n"
17584                 "    the number of elements is 2, and the corresponding row elements of\n"
17585                 "    the values array are the minimum and maximum value represented by\n"
17586                 "    the colorbar.  For PL_COLORBAR_SHADE, the number and values of the\n"
17587                 "    elements of a row of the values array is interpreted the same as\n"
17588                 "    the nlevel and clevel arguments of plshades. \n"
17589                 "\n"
17590                 ""},
17591          { (char *)"pllightsource", _wrap_pllightsource, METH_VARARGS, (char *)"\n"
17592                 "Sets the 3D position of the light source \n"
17593                 "\n"
17594                 "DESCRIPTION:\n"
17595                 "\n"
17596                 "    Sets the 3D position of the light source for use with plsurf3d. \n"
17597                 "\n"
17598                 "    Redacted form: pllightsource(x, y, z)\n"
17599                 "\n"
17600                 "    This function is used in example 8. \n"
17601                 "\n"
17602                 "\n"
17603                 "\n"
17604                 "SYNOPSIS:\n"
17605                 "\n"
17606                 "pllightsource(x, y, z)\n"
17607                 "\n"
17608                 "ARGUMENTS:\n"
17609                 "\n"
17610                 "    x (PLFLT, input) :      X-coordinate of the light source. \n"
17611                 "\n"
17612                 "    y (PLFLT, input) :      Y-coordinate of the light source. \n"
17613                 "\n"
17614                 "    z (PLFLT, input) :      Z-coordinate of the light source. \n"
17615                 "\n"
17616                 ""},
17617          { (char *)"plline", _wrap_plline, METH_VARARGS, (char *)"\n"
17618                 "Draw a line \n"
17619                 "\n"
17620                 "DESCRIPTION:\n"
17621                 "\n"
17622                 "    Draws line defined by n points in x and y. \n"
17623                 "\n"
17624                 "    Redacted form: plline(x, y)\n"
17625                 "\n"
17626                 "    This function is used in examples 1,3,4,9,12-14,16,18,20,22,25-27,29. \n"
17627                 "\n"
17628                 "\n"
17629                 "\n"
17630                 "SYNOPSIS:\n"
17631                 "\n"
17632                 "plline(n, x, y)\n"
17633                 "\n"
17634                 "ARGUMENTS:\n"
17635                 "\n"
17636                 "    n (PLINT, input) :      Number of points defining line. \n"
17637                 "\n"
17638                 "    x (const PLFLT *, input) :      Pointer to array with x coordinates of\n"
17639                 "    points. \n"
17640                 "\n"
17641                 "    y (const PLFLT *, input) :      Pointer to array with y coordinates of\n"
17642                 "    points. \n"
17643                 "\n"
17644                 ""},
17645          { (char *)"plline3", _wrap_plline3, METH_VARARGS, (char *)"\n"
17646                 "Draw a line in 3 space \n"
17647                 "\n"
17648                 "DESCRIPTION:\n"
17649                 "\n"
17650                 "    Draws line in 3 space defined by n points in x, y, and z. You must\n"
17651                 "    first set up the viewport, the 2d viewing window (in world\n"
17652                 "    coordinates), and the 3d normalized coordinate box.  See x18c.c for\n"
17653                 "    more info. \n"
17654                 "\n"
17655                 "    Redacted form: plline3(x, y, z)\n"
17656                 "\n"
17657                 "    This function is used in example 18. \n"
17658                 "\n"
17659                 "\n"
17660                 "\n"
17661                 "SYNOPSIS:\n"
17662                 "\n"
17663                 "plline3(n, x, y, z)\n"
17664                 "\n"
17665                 "ARGUMENTS:\n"
17666                 "\n"
17667                 "    n (PLINT, input) :      Number of points defining line. \n"
17668                 "\n"
17669                 "    x (const PLFLT *, input) :      Pointer to array with x coordinates of\n"
17670                 "    points. \n"
17671                 "\n"
17672                 "    y (const PLFLT *, input) :      Pointer to array with y coordinates of\n"
17673                 "    points. \n"
17674                 "\n"
17675                 "    z (const PLFLT *, input) :      Pointer to array with z coordinates of\n"
17676                 "    points. \n"
17677                 "\n"
17678                 ""},
17679          { (char *)"pllsty", _wrap_pllsty, METH_VARARGS, (char *)"\n"
17680                 "Select line style \n"
17681                 "\n"
17682                 "DESCRIPTION:\n"
17683                 "\n"
17684                 "    This sets the line style according to one of eight predefined patterns\n"
17685                 "    (also see plstyl). \n"
17686                 "\n"
17687                 "    Redacted form: pllsty(lin)\n"
17688                 "\n"
17689                 "    This function is used in examples 9,12,22,25. \n"
17690                 "\n"
17691                 "\n"
17692                 "\n"
17693                 "SYNOPSIS:\n"
17694                 "\n"
17695                 "pllsty(lin)\n"
17696                 "\n"
17697                 "ARGUMENTS:\n"
17698                 "\n"
17699                 "    lin (PLINT, input) :    Integer value between 1 and 8. Line style 1 is\n"
17700                 "    a continuous line, line style 2 is a line with short dashes and\n"
17701                 "    gaps, line style 3 is a line with long dashes and gaps, line style\n"
17702                 "    4 has long dashes and short gaps and so on. \n"
17703                 "\n"
17704                 ""},
17705          { (char *)"plmesh", _wrap_plmesh, METH_VARARGS, (char *)"\n"
17706                 "Plot surface mesh \n"
17707                 "\n"
17708                 "DESCRIPTION:\n"
17709                 "\n"
17710                 "    Plots a surface mesh within the environment set up by plw3d.  The\n"
17711                 "    surface is defined by the two-dimensional array z[\n"
17712                 "    nx][\n"
17713                 "    ny], the point z[i][j] being the value of the function at (\n"
17714                 "    x[i], \n"
17715                 "    y[j]).  Note that the points in arrays x and y do not need to be\n"
17716                 "    equally spaced, but must be stored in ascending order.  The parameter\n"
17717                 "    opt controls the way in which the surface is displayed.  For further\n"
17718                 "    details see the PLplot documentation. \n"
17719                 "\n"
17720                 "    Redacted form: plmesh(x, y, z, opt)\n"
17721                 "\n"
17722                 "    This function is used in example 11. \n"
17723                 "\n"
17724                 "\n"
17725                 "\n"
17726                 "SYNOPSIS:\n"
17727                 "\n"
17728                 "plmesh(x, y, z, nx, ny, opt)\n"
17729                 "\n"
17730                 "ARGUMENTS:\n"
17731                 "\n"
17732                 "    x (const PLFLT *, input) :      Pointer to set of x coordinate values at\n"
17733                 "    which the function is evaluated. \n"
17734                 "\n"
17735                 "    y (const PLFLT *, input) :      Pointer to set of y coordinate values at\n"
17736                 "    which the function is evaluated. \n"
17737                 "\n"
17738                 "    z (const PLFLT * const *, input) :      Pointer to a vectored\n"
17739                 "    two-dimensional array with set of function values. \n"
17740                 "\n"
17741                 "    nx (PLINT, input) :    Number of x values at which function is\n"
17742                 "    evaluated. \n"
17743                 "\n"
17744                 "    ny (PLINT, input) :    Number of y values at which function is\n"
17745                 "    evaluated. \n"
17746                 "\n"
17747                 "    opt (PLINT, input) :    Determines the way in which the surface is\n"
17748                 "    represented: opt=DRAW_LINEX: Lines are drawn showing z as a\n"
17749                 "    function of x for each value of y[j]. \n"
17750                 "        opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
17751                 "        for each value of x[i]. \n"
17752                 "        opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
17753                 "        at which function is defined. \n"
17754                 "\n"
17755                 ""},
17756          { (char *)"plmeshc", _wrap_plmeshc, METH_VARARGS, (char *)"\n"
17757                 "Magnitude colored plot surface mesh with contour \n"
17758                 "\n"
17759                 "DESCRIPTION:\n"
17760                 "\n"
17761                 "    A more powerful form of plmesh: the surface mesh can be colored\n"
17762                 "    accordingly to the current z value being plotted, a contour plot can\n"
17763                 "    be drawn at the base XY plane, and a curtain can be drawn between the\n"
17764                 "    plotted function border and the base XY plane. \n"
17765                 "\n"
17766                 "    Redacted form: plmeshc(x, y, z, opt, clevel)\n"
17767                 "\n"
17768                 "    This function is used in example 11. \n"
17769                 "\n"
17770                 "\n"
17771                 "\n"
17772                 "SYNOPSIS:\n"
17773                 "\n"
17774                 "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
17775                 "\n"
17776                 "ARGUMENTS:\n"
17777                 "\n"
17778                 "    x (const PLFLT *, input) :      Pointer to set of x coordinate values at\n"
17779                 "    which the function is evaluated. \n"
17780                 "\n"
17781                 "    y (const PLFLT *, input) :      Pointer to set of y coordinate values at\n"
17782                 "    which the function is evaluated. \n"
17783                 "\n"
17784                 "    z (const PLFLT * const *, input) :      Pointer to a vectored\n"
17785                 "    two-dimensional array with set of function values. \n"
17786                 "\n"
17787                 "    nx (PLINT, input) :    Number of x values at which function is\n"
17788                 "    evaluated. \n"
17789                 "\n"
17790                 "    ny (PLINT, input) :    Number of y values at which function is\n"
17791                 "    evaluated. \n"
17792                 "\n"
17793                 "    opt (PLINT, input) :    Determines the way in which the surface is\n"
17794                 "    represented. To specify more than one option just add the options,\n"
17795                 "    e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX: Lines are drawn\n"
17796                 "    showing z as a function of x for each value of y[j]. \n"
17797                 "        opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
17798                 "        for each value of x[i]. \n"
17799                 "        opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
17800                 "        at which function is defined. \n"
17801                 "        opt=MAG_COLOR: Each line in the mesh is colored according to\n"
17802                 "        the z value being plotted. The color is used from the current\n"
17803                 "        color map 1. \n"
17804                 "        opt=BASE_CONT: A contour plot is drawn at the base XY plane\n"
17805                 "        using parameters \n"
17806                 "    nlevel and \n"
17807                 "    clevel. \n"
17808                 "        opt=DRAW_SIDES: draws a curtain between the base XY plane and\n"
17809                 "        the borders of the plotted function. \n"
17810                 "\n"
17811                 "\n"
17812                 "    clevel (const PLFLT *, input) :    Pointer to the array that defines\n"
17813                 "    the contour level spacing. \n"
17814                 "\n"
17815                 "    nlevel (PLINT, input) :    Number of elements in the clevel array. \n"
17816                 "\n"
17817                 ""},
17818          { (char *)"plmkstrm", _wrap_plmkstrm, METH_VARARGS, (char *)"\n"
17819                 "Creates a new stream and makes it the default \n"
17820                 "\n"
17821                 "DESCRIPTION:\n"
17822                 "\n"
17823                 "    Creates a new stream and makes it the default.  Differs from using\n"
17824                 "    plsstrm, in that a free stream number is found, and returned.\n"
17825                 "    Unfortunately, I have to start at stream 1 and work upward, since\n"
17826                 "    stream 0 is preallocated.  One of the big flaws in the PLplot API is\n"
17827                 "    that no initial, library-opening call is required. So stream 0 must\n"
17828                 "    be preallocated, and there is no simple way of determining whether it\n"
17829                 "    is already in use or not. \n"
17830                 "\n"
17831                 "    Redacted form: plmkstrm(p_strm)\n"
17832                 "\n"
17833                 "    This function is used in examples 1,20. \n"
17834                 "\n"
17835                 "\n"
17836                 "\n"
17837                 "SYNOPSIS:\n"
17838                 "\n"
17839                 "plmkstrm(p_strm)\n"
17840                 "\n"
17841                 "ARGUMENTS:\n"
17842                 "\n"
17843                 "    p_strm (PLINT *, output) :      Pointer to stream number of the created\n"
17844                 "    stream. \n"
17845                 "\n"
17846                 ""},
17847          { (char *)"plmtex", _wrap_plmtex, METH_VARARGS, (char *)"\n"
17848                 "Write text relative to viewport boundaries \n"
17849                 "\n"
17850                 "DESCRIPTION:\n"
17851                 "\n"
17852                 "    Writes text at a specified position relative to the viewport\n"
17853                 "    boundaries.  Text may be written inside or outside the viewport, but\n"
17854                 "    is clipped at the subpage boundaries.  The reference point of a string\n"
17855                 "    lies along a line passing through the string at half the height of a\n"
17856                 "    capital letter.  The position of the reference point along this line\n"
17857                 "    is determined by just, and the position of the reference point\n"
17858                 "    relative to the viewport is set by disp and pos. \n"
17859                 "\n"
17860                 "    Redacted form:  General: plmtex(side, disp, pos, just, text)\n"
17861                 "           Perl/PDL: plmtex(disp, pos, just, side, text)\n"
17862                 "\n"
17863                 "\n"
17864                 "    This function is used in examples 3,4,6-8,11,12,14,18,23,26. \n"
17865                 "\n"
17866                 "\n"
17867                 "\n"
17868                 "SYNOPSIS:\n"
17869                 "\n"
17870                 "plmtex(side, disp, pos, just, text)\n"
17871                 "\n"
17872                 "ARGUMENTS:\n"
17873                 "\n"
17874                 "    side (const char *, input) :    Specifies the side of the viewport\n"
17875                 "    along which the text is to be written. The string must be one of:\n"
17876                 "    b: Bottom of viewport, text written parallel to edge. \n"
17877                 "        bv: Bottom of viewport, text written at right angles to edge. \n"
17878                 "        l: Left of viewport, text written parallel to edge. \n"
17879                 "        lv: Left of viewport, text written at right angles to edge. \n"
17880                 "        r: Right of viewport, text written parallel to edge. \n"
17881                 "        rv: Right of viewport, text written at right angles to edge. \n"
17882                 "        t: Top of viewport, text written parallel to edge. \n"
17883                 "        tv: Top of viewport, text written at right angles to edge. \n"
17884                 "\n"
17885                 "\n"
17886                 "    disp (PLFLT, input) :    Position of the reference point of string,\n"
17887                 "    measured outwards from the specified viewport edge in units of the\n"
17888                 "    current character height.  Use negative disp to write within the\n"
17889                 "    viewport. \n"
17890                 "\n"
17891                 "    pos (PLFLT, input) :    Position of the reference point of string\n"
17892                 "    along the specified edge, expressed as a fraction of the length of\n"
17893                 "    the edge. \n"
17894                 "\n"
17895                 "    just (PLFLT, input) :    Specifies the position of the string relative\n"
17896                 "    to its reference point.  If just=0., the reference point is at the\n"
17897                 "    left and if just=1., it is at the right of the string.    Other\n"
17898                 "    values of just give intermediate justifications. \n"
17899                 "\n"
17900                 "    text (const char *, input) :    The string to be written out. \n"
17901                 "\n"
17902                 ""},
17903          { (char *)"plmtex3", _wrap_plmtex3, METH_VARARGS, (char *)"\n"
17904                 "Write text relative to viewport boundaries in 3D plots \n"
17905                 "\n"
17906                 "DESCRIPTION:\n"
17907                 "\n"
17908                 "    Writes text at a specified position relative to the viewport\n"
17909                 "    boundaries.  Text may be written inside or outside the viewport, but\n"
17910                 "    is clipped at the subpage boundaries.  The reference point of a string\n"
17911                 "    lies along a line passing through the string at half the height of a\n"
17912                 "    capital letter.  The position of the reference point along this line\n"
17913                 "    is determined by just, and the position of the reference point\n"
17914                 "    relative to the viewport is set by disp and pos. \n"
17915                 "\n"
17916                 "    Redacted form: plmtex3(side, disp, pos, just, text)\n"
17917                 "\n"
17918                 "    This function is used in example 28. \n"
17919                 "\n"
17920                 "\n"
17921                 "\n"
17922                 "SYNOPSIS:\n"
17923                 "\n"
17924                 "plmtex3(side, disp, pos, just, text)\n"
17925                 "\n"
17926                 "ARGUMENTS:\n"
17927                 "\n"
17928                 "    side (const char *, input) :    Specifies the side of the viewport\n"
17929                 "    along which the text is to be written. The string should contain\n"
17930                 "    one or more of the following characters: [xyz][ps][v].    Only one\n"
17931                 "    label is drawn at a time, i.e. xyp will only label the X axis, not\n"
17932                 "    both the X and Y axes. x: Label the X axis. \n"
17933                 "        y: Label the Y axis. \n"
17934                 "        z: Label the Z axis. \n"
17935                 "        p: Label the primary axis. For Z this is the leftmost Z axis.\n"
17936                 "        For X it is the axis that starts at y-min. For Y it is the\n"
17937                 "        axis that starts at x-min. \n"
17938                 "        s: Label the secondary axis. \n"
17939                 "        v: Draw the text perpendicular to the axis. \n"
17940                 "\n"
17941                 "\n"
17942                 "    disp (PLFLT, input) :    Position of the reference point of string,\n"
17943                 "    measured outwards from the specified viewport edge in units of the\n"
17944                 "    current character height.  Use negative disp to write within the\n"
17945                 "    viewport. \n"
17946                 "\n"
17947                 "    pos (PLFLT, input) :    Position of the reference point of string\n"
17948                 "    along the specified edge, expressed as a fraction of the length of\n"
17949                 "    the edge. \n"
17950                 "\n"
17951                 "    just (PLFLT, input) :    Specifies the position of the string relative\n"
17952                 "    to its reference point.  If just=0., the reference point is at the\n"
17953                 "    left and if just=1., it is at the right of the string.    Other\n"
17954                 "    values of just give intermediate justifications. \n"
17955                 "\n"
17956                 "    text (const char *, input) :    The string to be written out. \n"
17957                 "\n"
17958                 ""},
17959          { (char *)"plot3d", _wrap_plot3d, METH_VARARGS, (char *)"\n"
17960                 "Plot 3-d surface plot \n"
17961                 "\n"
17962                 "DESCRIPTION:\n"
17963                 "\n"
17964                 "    Plots a three dimensional surface plot within the environment set up\n"
17965                 "    by plw3d.  The surface is defined by the two-dimensional array z[\n"
17966                 "    nx][\n"
17967                 "    ny], the point z[i][j] being the value of the function at (\n"
17968                 "    x[i], \n"
17969                 "    y[j]).  Note that the points in arrays x and y do not need to be\n"
17970                 "    equally spaced, but must be stored in ascending order.  The parameter\n"
17971                 "    opt controls the way in which the surface is displayed.  For further\n"
17972                 "    details see the PLplot documentation. The only difference between\n"
17973                 "    plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
17974                 "    while plot3d only draws the surface as viewed from the top. \n"
17975                 "\n"
17976                 "    Redacted form: plot3d(x, y, z, opt, side)\n"
17977                 "\n"
17978                 "    This function is used in examples 11,21. \n"
17979                 "\n"
17980                 "\n"
17981                 "\n"
17982                 "SYNOPSIS:\n"
17983                 "\n"
17984                 "plot3d(x, y, z, nx, ny, opt, side)\n"
17985                 "\n"
17986                 "ARGUMENTS:\n"
17987                 "\n"
17988                 "    x (const PLFLT *, input) :      Pointer to set of x coordinate values at\n"
17989                 "    which the function is evaluated. \n"
17990                 "\n"
17991                 "    y (const PLFLT *, input) :      Pointer to set of y coordinate values at\n"
17992                 "    which the function is evaluated. \n"
17993                 "\n"
17994                 "    z (const PLFLT * const *, input) :      Pointer to a vectored\n"
17995                 "    two-dimensional array with set of function values. \n"
17996                 "\n"
17997                 "    nx (PLINT, input) :    Number of x values at which function is\n"
17998                 "    evaluated. \n"
17999                 "\n"
18000                 "    ny (PLINT, input) :    Number of y values at which function is\n"
18001                 "    evaluated. \n"
18002                 "\n"
18003                 "    opt (PLINT, input) :    Determines the way in which the surface is\n"
18004                 "    represented: opt=DRAW_LINEX: Lines are drawn showing z as a\n"
18005                 "    function of x for each value of y[j]. \n"
18006                 "        opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
18007                 "        for each value of x[i]. \n"
18008                 "        opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
18009                 "        at which function is defined. \n"
18010                 "\n"
18011                 "\n"
18012                 "    side (PLBOOL, input) :    Flag to indicate whether or not ``sides''\n"
18013                 "    should be draw on the figure.  If side is true sides are drawn,\n"
18014                 "    otherwise no sides are drawn. \n"
18015                 "\n"
18016                 ""},
18017          { (char *)"plot3dc", _wrap_plot3dc, METH_VARARGS, (char *)"\n"
18018                 "Magnitude colored plot surface with contour \n"
18019                 "\n"
18020                 "DESCRIPTION:\n"
18021                 "\n"
18022                 "    Aside from dropping the \n"
18023                 "    side functionality this is a more powerful form of plot3d: the surface\n"
18024                 "    mesh can be colored accordingly to the current z value being plotted,\n"
18025                 "    a contour plot can be drawn at the base XY plane, and a curtain can be\n"
18026                 "    drawn between the plotted function border and the base XY plane. The\n"
18027                 "    arguments are identical to those of plmeshc. The only difference\n"
18028                 "    between plmeshc and plot3dc is that plmeshc draws the bottom side of\n"
18029                 "    the surface, while plot3dc only draws the surface as viewed from the\n"
18030                 "    top. \n"
18031                 "\n"
18032                 "    Redacted form:  General: plot3dc(x, y, z, opt, clevel)\n"
18033                 "           Perl/PDL: Not available? \n"
18034                 "\n"
18035                 "\n"
18036                 "    This function is used in example 21. \n"
18037                 "\n"
18038                 "\n"
18039                 "\n"
18040                 "SYNOPSIS:\n"
18041                 "\n"
18042                 "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18043                 "\n"
18044                 "ARGUMENTS:\n"
18045                 "\n"
18046                 "    x (const PLFLT *, input) :      Pointer to set of x coordinate values at\n"
18047                 "    which the function is evaluated. \n"
18048                 "\n"
18049                 "    y (const PLFLT *, input) :      Pointer to set of y coordinate values at\n"
18050                 "    which the function is evaluated. \n"
18051                 "\n"
18052                 "    z (const PLFLT * const *, input) :      Pointer to a vectored\n"
18053                 "    two-dimensional array with set of function values. \n"
18054                 "\n"
18055                 "    nx (PLINT, input) :    Number of x values at which function is\n"
18056                 "    evaluated. \n"
18057                 "\n"
18058                 "    ny (PLINT, input) :    Number of y values at which function is\n"
18059                 "    evaluated. \n"
18060                 "\n"
18061                 "    opt (PLINT, input) :    Determines the way in which the surface is\n"
18062                 "    represented. To specify more than one option just add the options,\n"
18063                 "    e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX: Lines are drawn\n"
18064                 "    showing z as a function of x for each value of y[j]. \n"
18065                 "        opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
18066                 "        for each value of x[i]. \n"
18067                 "        opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
18068                 "        at which function is defined. \n"
18069                 "        opt=MAG_COLOR: Each line in the mesh is colored according to\n"
18070                 "        the z value being plotted. The color is used from the current\n"
18071                 "        color map 1. \n"
18072                 "        opt=BASE_CONT: A contour plot is drawn at the base XY plane\n"
18073                 "        using parameters \n"
18074                 "    nlevel and \n"
18075                 "    clevel. \n"
18076                 "        opt=DRAW_SIDES: draws a curtain between the base XY plane and\n"
18077                 "        the borders of the plotted function. \n"
18078                 "\n"
18079                 "\n"
18080                 "    clevel (const PLFLT *, input) :    Pointer to the array that defines\n"
18081                 "    the contour level spacing. \n"
18082                 "\n"
18083                 "    nlevel (PLINT, input) :    Number of elements in the clevel array. \n"
18084                 "\n"
18085                 ""},
18086          { (char *)"plot3dcl", _wrap_plot3dcl, METH_VARARGS, (char *)"\n"
18087                 "Magnitude colored plot surface with contour for z[x][y] with y index limits \n"
18088                 "\n"
18089                 "DESCRIPTION:\n"
18090                 "\n"
18091                 "    When the implementation is completed this variant of plot3dc (see that\n"
18092                 "    function's documentation for more details) should be suitable for the\n"
18093                 "    case where the area of the x, y coordinate grid where z is defined can\n"
18094                 "    be non-rectangular. The implementation is incomplete so the last 4\n"
18095                 "    parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n"
18096                 "    indexymax; are currently ignored and the functionality is otherwise\n"
18097                 "    identical to that of plot3dc. \n"
18098                 "\n"
18099                 "    Redacted form:  General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n"
18100                 "    indexymin, indexymax)\n"
18101                 "           Perl/PDL: Not available? \n"
18102                 "\n"
18103                 "\n"
18104                 "    This function is not used in any example. \n"
18105                 "\n"
18106                 "\n"
18107                 "\n"
18108                 "SYNOPSIS:\n"
18109                 "\n"
18110                 "plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18111                 "\n"
18112                 "ARGUMENTS:\n"
18113                 "\n"
18114                 "    x (const PLFLT *, input) :      Pointer to set of x coordinate values at\n"
18115                 "    which the function is evaluated. \n"
18116                 "\n"
18117                 "    y (const PLFLT *, input) :      Pointer to set of y coordinate values at\n"
18118                 "    which the function is evaluated. \n"
18119                 "\n"
18120                 "    z (const PLFLT * const *, input) :      Pointer to a vectored\n"
18121                 "    two-dimensional array with set of function values. \n"
18122                 "\n"
18123                 "    nx (PLINT, input) :    Number of x values at which the function is\n"
18124                 "    evaluated. \n"
18125                 "\n"
18126                 "    ny (PLINT, input) :    Number of y values at which the function is\n"
18127                 "    evaluated. \n"
18128                 "\n"
18129                 "    opt (PLINT, input) :    Determines the way in which the surface is\n"
18130                 "    represented. To specify more than one option just add the options,\n"
18131                 "    e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX: Lines are drawn\n"
18132                 "    showing z as a function of x for each value of y[j]. \n"
18133                 "        opt=DRAW_LINEY: Lines are drawn showing z as a function of y\n"
18134                 "        for each value of x[i]. \n"
18135                 "        opt=DRAW_LINEXY: Network of lines is drawn connecting points\n"
18136                 "        at which function is defined. \n"
18137                 "        opt=MAG_COLOR: Each line in the mesh is colored according to\n"
18138                 "        the z value being plotted. The color is used from the current\n"
18139                 "        color map 1. \n"
18140                 "        opt=BASE_CONT: A contour plot is drawn at the base XY plane\n"
18141                 "        using parameters \n"
18142                 "    nlevel and \n"
18143                 "    clevel. \n"
18144                 "        opt=DRAW_SIDES: draws a curtain between the base XY plane and\n"
18145                 "        the borders of the plotted function. \n"
18146                 "\n"
18147                 "\n"
18148                 "    clevel (const PLFLT *, input) :    Pointer to the array that defines\n"
18149                 "    the contour level spacing. \n"
18150                 "\n"
18151                 "    nlevel (PLINT, input) :    Number of elements in the clevel array. \n"
18152                 "\n"
18153                 "    indexxmin (PLINT, input) :      The index value (which must be ≥ 0) that\n"
18154                 "    corresponds to the first x index where z is defined. \n"
18155                 "\n"
18156                 "    indexxmax (PLINT, input) :      The index value (which must be ≤ nx)\n"
18157                 "    which corresponds (by convention) to one more than the last x\n"
18158                 "    index value where z is defined. \n"
18159                 "\n"
18160                 "    indexymin (const PLINT *, input) :      Array of y index values which\n"
18161                 "    all must be ≥ 0.  These values are the first y index where z is\n"
18162                 "    defined for a particular x index in the range from indexxmin to\n"
18163                 "    indexxmax - 1.    The dimension of indexymin is indexxmax. \n"
18164                 "\n"
18165                 "    indexymax (const PLINT *, input) :      Array of y index values which\n"
18166                 "    all must be ≤ ny.  These values correspond (by convention) to one\n"
18167                 "    more than the last y index where z is defined for a particular x\n"
18168                 "    index in the range from indexxmin to indexxmax - 1.  The dimension\n"
18169                 "    of indexymax is indexxmax. \n"
18170                 "\n"
18171                 ""},
18172          { (char *)"plsurf3d", _wrap_plsurf3d, METH_VARARGS, (char *)"\n"
18173                 "Plot shaded 3-d surface plot \n"
18174                 "\n"
18175                 "DESCRIPTION:\n"
18176                 "\n"
18177                 "    Plots a three dimensional shaded surface plot within the environment\n"
18178                 "    set up by plw3d.  The surface is defined by the two-dimensional array\n"
18179                 "    z[\n"
18180                 "    nx][\n"
18181                 "    ny], the point z[i][j] being the value of the function at (\n"
18182                 "    x[i], \n"
18183                 "    y[j]).  Note that the points in arrays x and y do not need to be\n"
18184                 "    equally spaced, but must be stored in ascending order. For further\n"
18185                 "    details see the PLplot documentation. \n"
18186                 "\n"
18187                 "    Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
18188                 "\n"
18189                 "    This function is not used in any examples. \n"
18190                 "\n"
18191                 "\n"
18192                 "\n"
18193                 "SYNOPSIS:\n"
18194                 "\n"
18195                 "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18196                 "\n"
18197                 "ARGUMENTS:\n"
18198                 "\n"
18199                 "    x (const PLFLT *, input) :      Pointer to set of x coordinate values at\n"
18200                 "    which the function is evaluated. \n"
18201                 "\n"
18202                 "    y (const PLFLT *, input) :      Pointer to set of y coordinate values at\n"
18203                 "    which the function is evaluated. \n"
18204                 "\n"
18205                 "    z (const PLFLT * const *, input) :      Pointer to a vectored\n"
18206                 "    two-dimensional array with set of function values. \n"
18207                 "\n"
18208                 "    nx (PLINT, input) :    Number of x values at which function is\n"
18209                 "    evaluated. \n"
18210                 "\n"
18211                 "    ny (PLINT, input) :    Number of y values at which function is\n"
18212                 "    evaluated. \n"
18213                 "\n"
18214                 "    opt (PLINT, input) :    Determines the way in which the surface is\n"
18215                 "    represented. To specify more than one option just add the options,\n"
18216                 "    e.g. FACETED + SURF_CONT opt=FACETED: Network of lines is drawn\n"
18217                 "    connecting points at which function is defined. \n"
18218                 "        opt=BASE_CONT: A contour plot is drawn at the base XY plane\n"
18219                 "        using parameters \n"
18220                 "    nlevel and \n"
18221                 "    clevel. \n"
18222                 "        opt=SURF_CONT: A contour plot is drawn at the surface plane\n"
18223                 "        using parameters \n"
18224                 "    nlevel and \n"
18225                 "    clevel. \n"
18226                 "        opt=DRAW_SIDES: draws a curtain between the base XY plane and\n"
18227                 "        the borders of the plotted function. \n"
18228                 "        opt=MAG_COLOR: the surface is colored according to the value\n"
18229                 "        of Z; if MAG_COLOR is not used, then the default the surface\n"
18230                 "        is colored according to the intensity of the reflected light\n"
18231                 "        in the surface from a light source whose position is set using\n"
18232                 "        pllightsource. \n"
18233                 "\n"
18234                 "\n"
18235                 "    clevel (const PLFLT *, input) :    Pointer to the array that defines\n"
18236                 "    the contour level spacing. \n"
18237                 "\n"
18238                 "    nlevel (PLINT, input) :    Number of elements in the clevel array. \n"
18239                 "\n"
18240                 ""},
18241          { (char *)"plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, (char *)"\n"
18242                 "Plot shaded 3-d surface plot for z[x][y] with y index limits \n"
18243                 "\n"
18244                 "DESCRIPTION:\n"
18245                 "\n"
18246                 "    This variant of plsurf3d (see that function's documentation for more\n"
18247                 "    details) should be suitable for the case where the area of the x, y\n"
18248                 "    coordinate grid where z is defined can be non-rectangular. The limits\n"
18249                 "    of that grid are provided by the parameters indexxmin, indexxmax,\n"
18250                 "    indexymin, and indexymax. \n"
18251                 "\n"
18252                 "    Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n"
18253                 "    indexymax)\n"
18254                 "\n"
18255                 "    This function is not used in any examples. \n"
18256                 "\n"
18257                 "\n"
18258                 "\n"
18259                 "SYNOPSIS:\n"
18260                 "\n"
18261                 "plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18262                 "\n"
18263                 "ARGUMENTS:\n"
18264                 "\n"
18265                 "    x (const PLFLT *, input) :      Pointer to set of x coordinate values at\n"
18266                 "    which the function is evaluated. \n"
18267                 "\n"
18268                 "    y (const PLFLT *, input) :      Pointer to set of y coordinate values at\n"
18269                 "    which the function is evaluated. \n"
18270                 "\n"
18271                 "    z (const PLFLT * const *, input) :      Pointer to a vectored\n"
18272                 "    two-dimensional array with set of function values. \n"
18273                 "\n"
18274                 "    nx (PLINT, input) :    Number of x values at which function is\n"
18275                 "    evaluated. \n"
18276                 "\n"
18277                 "    ny (PLINT, input) :    Number of y values at which function is\n"
18278                 "    evaluated. \n"
18279                 "\n"
18280                 "    opt (PLINT, input) :    Determines the way in which the surface is\n"
18281                 "    represented. To specify more than one option just add the options,\n"
18282                 "    e.g. FACETED + SURF_CONT opt=FACETED: Network of lines is drawn\n"
18283                 "    connecting points at which function is defined. \n"
18284                 "        opt=BASE_CONT: A contour plot is drawn at the base XY plane\n"
18285                 "        using parameters \n"
18286                 "    nlevel and \n"
18287                 "    clevel. \n"
18288                 "        opt=SURF_CONT: A contour plot is drawn at the surface plane\n"
18289                 "        using parameters \n"
18290                 "    nlevel and \n"
18291                 "    clevel. \n"
18292                 "        opt=DRAW_SIDES: draws a curtain between the base XY plane and\n"
18293                 "        the borders of the plotted function. \n"
18294                 "        opt=MAG_COLOR: the surface is colored according to the value\n"
18295                 "        of Z; if MAG_COLOR is not used, then the default the surface\n"
18296                 "        is colored according to the intensity of the reflected light\n"
18297                 "        in the surface from a light source whose position is set using\n"
18298                 "        pllightsource. \n"
18299                 "\n"
18300                 "\n"
18301                 "    clevel (const PLFLT *, input) :    Pointer to the array that defines\n"
18302                 "    the contour level spacing. \n"
18303                 "\n"
18304                 "    nlevel (PLINT, input) :    Number of elements in the clevel array. \n"
18305                 "\n"
18306                 "    indexxmin (PLINT, input) :      The index value (which must be ≥ 0) that\n"
18307                 "    corresponds to the first x index where z is defined. \n"
18308                 "\n"
18309                 "    indexxmax (PLINT, input) :      The index value (which must be ≤ nx)\n"
18310                 "    which corresponds (by convention) to one more than the last x\n"
18311                 "    index value where z is defined. \n"
18312                 "\n"
18313                 "    indexymin (const PLINT *, input) :      Array of y index values which\n"
18314                 "    all must be ≥ 0.  These values are the first y index where z is\n"
18315                 "    defined for a particular x index in the range from indexxmin to\n"
18316                 "    indexxmax - 1.    The dimension of indexymin is indexxmax. \n"
18317                 "\n"
18318                 "    indexymax (const PLINT *, input) :      Array of y index values which\n"
18319                 "    all must be ≤ ny.  These values correspond (by convention) to one\n"
18320                 "    more than the last y index where z is defined for a particular x\n"
18321                 "    index in the range from indexxmin to indexxmax - 1.  The dimension\n"
18322                 "    of indexymax is indexxmax. \n"
18323                 "\n"
18324                 ""},
18325          { (char *)"plparseopts", _wrap_plparseopts, METH_VARARGS, (char *)"\n"
18326                 "Parse command-line arguments \n"
18327                 "\n"
18328                 "DESCRIPTION:\n"
18329                 "\n"
18330                 "    Parse command-line arguments. \n"
18331                 "\n"
18332                 "    plparseopts removes all recognized flags (decreasing argc\n"
18333                 "    accordingly), so that invalid input may be readily detected.  It can\n"
18334                 "    also be used to process user command line flags.  The user can merge\n"
18335                 "    an option table of type PLOptionTable into the internal option table\n"
18336                 "    info structure using plMergeOpts.  Or, the user can specify that ONLY\n"
18337                 "    the external table(s) be parsed by calling plClearOpts before\n"
18338                 "    plMergeOpts. \n"
18339                 "\n"
18340                 "    The default action taken by plparseopts is as follows: \n"
18341                 "    Returns with an error if an unrecognized option or badly formed\n"
18342                 "    option-value pair are encountered. \n"
18343                 "    Returns immediately (return code 0) when the first non-option command\n"
18344                 "    line argument is found.  \n"
18345                 "    Returns with the return code of the option handler, if one was called.\n"
18346                 "     \n"
18347                 "    Deletes command line arguments from argv list as they are found, and\n"
18348                 "    decrements argc accordingly.  \n"
18349                 "    Does not show \"invisible\" options in usage or help messages.  \n"
18350                 "    Assumes the program name is contained in argv[0].  \n"
18351                 "\n"
18352                 "    These behaviors may be controlled through the  \n"
18353                 "    mode argument. \n"
18354                 "\n"
18355                 "    Redacted form:  General: plparseopts(argv, mode)\n"
18356                 "           Perl/PDL: Not available? \n"
18357                 "\n"
18358                 "\n"
18359                 "    This function is used in all of the examples. \n"
18360                 "\n"
18361                 "\n"
18362                 "\n"
18363                 "SYNOPSIS:\n"
18364                 "\n"
18365                 "int plparseopts(p_argc, argv, mode)\n"
18366                 "\n"
18367                 "ARGUMENTS:\n"
18368                 "\n"
18369                 "    p_argc (int *, input) :    pointer to number of arguments. \n"
18370                 "\n"
18371                 "    argv (const char **, input) :    Pointer to character array containing\n"
18372                 "    *p_argc command-line arguments. \n"
18373                 "\n"
18374                 "    mode (PLINT, input) :    Parsing mode with the following\n"
18375                 "    possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
18376                 "    and all error messages enabled, including program exit when an\n"
18377                 "    error occurs.  Anything on the command line that isn't recognized\n"
18378                 "    as a valid option or option argument is flagged as an error. \n"
18379                 "        PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
18380                 "        of errors. \n"
18381                 "        PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
18382                 "        arguments. \n"
18383                 "        PL_PARSE_SHOWALL (8) -- Show invisible options \n"
18384                 "        PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
18385                 "        pointer to the program name. \n"
18386                 "        PL_PARSE_NODASH (64) -- Set if leading dash is NOT required. \n"
18387                 "        PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
18388                 "        unrecognized arguments. \n"
18389                 "\n"
18390                 ""},
18391          { (char *)"plpat", _wrap_plpat, METH_VARARGS, (char *)"\n"
18392                 "Set area fill pattern \n"
18393                 "\n"
18394                 "DESCRIPTION:\n"
18395                 "\n"
18396                 "    Sets the area fill pattern.  The pattern consists of 1 or 2 sets of\n"
18397                 "    parallel lines with specified inclinations and spacings.  The\n"
18398                 "    arguments to this routine are the number of sets to use (1 or 2)\n"
18399                 "    followed by two pointers to integer arrays (of 1 or 2 elements)\n"
18400                 "    specifying the inclinations in tenths of a degree and the spacing in\n"
18401                 "    micrometers.  (also see plpsty) \n"
18402                 "\n"
18403                 "    Redacted form:  General: plpat(inc, del)\n"
18404                 "           Perl/PDL: plpat(nlin, inc, del)\n"
18405                 "\n"
18406                 "\n"
18407                 "    This function is used in example 15. \n"
18408                 "\n"
18409                 "\n"
18410                 "\n"
18411                 "SYNOPSIS:\n"
18412                 "\n"
18413                 "plpat(nlin, inc, del)\n"
18414                 "\n"
18415                 "ARGUMENTS:\n"
18416                 "\n"
18417                 "    nlin (PLINT, input) :    Number of sets of lines making up the\n"
18418                 "    pattern, either 1 or 2. \n"
18419                 "\n"
18420                 "    inc (const PLINT *, input) :    Pointer to array with nlin elements.\n"
18421                 "    Specifies the line inclination in tenths of a degree.  (Should be\n"
18422                 "    between -900 and 900). \n"
18423                 "\n"
18424                 "    del (const PLINT *, input) :    Pointer to array with nlin elements.\n"
18425                 "    Specifies the spacing in micrometers between the lines making up\n"
18426                 "    the pattern. \n"
18427                 "\n"
18428                 ""},
18429          { (char *)"plpath", _wrap_plpath, METH_VARARGS, (char *)"\n"
18430                 "Draw a line between two points, accounting for coordinate transforms \n"
18431                 "\n"
18432                 "DESCRIPTION:\n"
18433                 "\n"
18434                 "    Joins the point (\n"
18435                 "    x1, \n"
18436                 "    y1) to (\n"
18437                 "    x2, \n"
18438                 "    y2).  If a global coordinate transform is defined then the line is\n"
18439                 "    broken in to n segments to approximate the path.  If no transform is\n"
18440                 "    defined then this simply acts like a call to pljoin. \n"
18441                 "\n"
18442                 "    Redacted form: plpath(n,x1,y1,x2,y2)\n"
18443                 "\n"
18444                 "    This function is used in example 22. \n"
18445                 "\n"
18446                 "\n"
18447                 "\n"
18448                 "SYNOPSIS:\n"
18449                 "\n"
18450                 "plpath(n, x1, y1, x2, y2)\n"
18451                 "\n"
18452                 "ARGUMENTS:\n"
18453                 "\n"
18454                 "    n (PLINT, input) :      number of points to use to approximate the path. \n"
18455                 "\n"
18456                 "    x1 (PLFLT, input) :    x coordinate of first point. \n"
18457                 "\n"
18458                 "    y1 (PLFLT, input) :    y coordinate of first point. \n"
18459                 "\n"
18460                 "    x2 (PLFLT, input) :    x coordinate of second point. \n"
18461                 "\n"
18462                 "    y2 (PLFLT, input) :    y coordinate of second point. \n"
18463                 "\n"
18464                 ""},
18465          { (char *)"plpoin", _wrap_plpoin, METH_VARARGS, (char *)"\n"
18466                 "Plot a glyph at the specified points \n"
18467                 "\n"
18468                 "DESCRIPTION:\n"
18469                 "\n"
18470                 "    Plot a glyph at the specified points.  (This function is largely\n"
18471                 "    superseded by plstring which gives access to many[!] more glyphs.)\n"
18472                 "    code=-1 means try to just draw a point.  Right now it's just a move\n"
18473                 "    and a draw at the same place.  Not ideal, since a sufficiently\n"
18474                 "    intelligent output device may optimize it away, or there may be faster\n"
18475                 "    ways of doing it.  This is OK for now, though, and offers a 4X speedup\n"
18476                 "    over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
18477                 "    and therefore takes 4 strokes to draw).  If 0 < code < 32, then a\n"
18478                 "    useful (but small subset) of Hershey symbols is plotted.  If 32 <=\n"
18479                 "    code <= 127 the corresponding printable ASCII character is plotted. \n"
18480                 "\n"
18481                 "    Redacted form: plpoin(x, y, code)\n"
18482                 "\n"
18483                 "    This function is used in examples 1,6,14,29. \n"
18484                 "\n"
18485                 "\n"
18486                 "\n"
18487                 "SYNOPSIS:\n"
18488                 "\n"
18489                 "plpoin(n, x, y, code)\n"
18490                 "\n"
18491                 "ARGUMENTS:\n"
18492                 "\n"
18493                 "    n (PLINT, input) :      Number of points in the x and y arrays. \n"
18494                 "\n"
18495                 "    x (const PLFLT *, input) :      Pointer to an array with X coordinates\n"
18496                 "    of points. \n"
18497                 "\n"
18498                 "    y (const PLFLT *, input) :      Pointer to an array with Y coordinates\n"
18499                 "    of points. \n"
18500                 "\n"
18501                 "    code (PLINT, input) :    Hershey symbol code (in \"ascii-indexed\" form\n"
18502                 "    with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
18503                 "    each of the n points. \n"
18504                 "\n"
18505                 ""},
18506          { (char *)"plpoin3", _wrap_plpoin3, METH_VARARGS, (char *)"\n"
18507                 "Plot a glyph at the specified 3D points \n"
18508                 "\n"
18509                 "DESCRIPTION:\n"
18510                 "\n"
18511                 "    Plot a glyph at the specified 3D points.  (This function is largely\n"
18512                 "    superseded by plstring3 which gives access to many[!] more glyphs.)\n"
18513                 "    Set up the call to this function similar to what is done for plline3.\n"
18514                 "    code=-1 means try to just draw a point.  Right now it's just a move\n"
18515                 "    and a draw at the same place.  Not ideal, since a sufficiently\n"
18516                 "    intelligent output device may optimize it away, or there may be faster\n"
18517                 "    ways of doing it.  This is OK for now, though, and offers a 4X speedup\n"
18518                 "    over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
18519                 "    and therefore takes 4 strokes to draw).  If 0 < code < 32, then a\n"
18520                 "    useful (but small subset) of Hershey symbols is plotted.  If 32 <=\n"
18521                 "    code <= 127 the corresponding printable ASCII character is plotted. \n"
18522                 "\n"
18523                 "    Redacted form: plpoin3(x, y, z, code)\n"
18524                 "\n"
18525                 "    This function is not used in any example. \n"
18526                 "\n"
18527                 "\n"
18528                 "\n"
18529                 "SYNOPSIS:\n"
18530                 "\n"
18531                 "plpoin3(n, x, y, z, code)\n"
18532                 "\n"
18533                 "ARGUMENTS:\n"
18534                 "\n"
18535                 "    n (PLINT, input) :      Number of points in the x and y arrays. \n"
18536                 "\n"
18537                 "    x (const PLFLT *, input) :      Pointer to an array with X coordinates\n"
18538                 "    of points. \n"
18539                 "\n"
18540                 "    y (const PLFLT *, input) :      Pointer to an array with Y coordinates\n"
18541                 "    of points. \n"
18542                 "\n"
18543                 "    z (const PLFLT *, input) :      Pointer to an array with Z coordinates\n"
18544                 "    of points. \n"
18545                 "\n"
18546                 "    code (PLINT, input) :    Hershey symbol code (in \"ascii-indexed\" form\n"
18547                 "    with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
18548                 "    each of the n points. \n"
18549                 "\n"
18550                 ""},
18551          { (char *)"plpoly3", _wrap_plpoly3, METH_VARARGS, (char *)"\n"
18552                 "Draw a polygon in 3 space \n"
18553                 "\n"
18554                 "DESCRIPTION:\n"
18555                 "\n"
18556                 "    Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
18557                 "    like plline3, but differs from that function in that plpoly3 attempts\n"
18558                 "    to determine if the polygon is viewable depending on the order of the\n"
18559                 "    points within the arrays and the value of ifcc.  If the back of\n"
18560                 "    polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
18561                 "    you want, then use plline3 instead. \n"
18562                 "\n"
18563                 "    The points are assumed to be in a plane, and the directionality of the\n"
18564                 "    plane is determined from the first three points.  Additional points do\n"
18565                 "    not have to lie on the plane defined by the first three, but if they\n"
18566                 "    do not, then the determination of visibility obviously can't be 100%\n"
18567                 "    accurate... So if you're 3 space polygons are too far from planar,\n"
18568                 "    consider breaking them into smaller polygons.  3 points define a plane\n"
18569                 "    :-). \n"
18570                 "\n"
18571                 "    Bugs:  If one of the first two segments is of zero length, or if they\n"
18572                 "    are co-linear, the calculation of visibility has a 50/50 chance of\n"
18573                 "    being correct.  Avoid such situations :-). See x18c.c for an example\n"
18574                 "    of this problem. (Search for 20.1). \n"
18575                 "\n"
18576                 "    Redacted form: plpoly3(x, y, z, code)\n"
18577                 "\n"
18578                 "    This function is used in example 18. \n"
18579                 "\n"
18580                 "\n"
18581                 "\n"
18582                 "SYNOPSIS:\n"
18583                 "\n"
18584                 "plpoly3(n, x, y, z, draw, ifcc)\n"
18585                 "\n"
18586                 "ARGUMENTS:\n"
18587                 "\n"
18588                 "    n (PLINT, input) :      Number of points defining line. \n"
18589                 "\n"
18590                 "    x (const PLFLT *, input) :      Pointer to array with x coordinates of\n"
18591                 "    points. \n"
18592                 "\n"
18593                 "    y (const PLFLT *, input) :      Pointer to array with y coordinates of\n"
18594                 "    points. \n"
18595                 "\n"
18596                 "    z (const PLFLT *, input) :      Pointer to array with z coordinates of\n"
18597                 "    points. \n"
18598                 "\n"
18599                 "    draw (const PLBOOL *, input) :    Pointer to array which controls\n"
18600                 "    drawing the segments of the polygon.  If draw[i] is true, then the\n"
18601                 "    polygon segment from index [i] to [i+1] is drawn, otherwise, not. \n"
18602                 "\n"
18603                 "    ifcc (PLBOOL, input) :    If ifcc is true the directionality of the\n"
18604                 "    polygon is determined by assuming the points are laid out in a\n"
18605                 "    counter-clockwise order.  Otherwise, the directionality of the\n"
18606                 "    polygon is determined by assuming the points are laid out in a\n"
18607                 "    clockwise order. \n"
18608                 "\n"
18609                 ""},
18610          { (char *)"plprec", _wrap_plprec, METH_VARARGS, (char *)"\n"
18611                 "Set precision in numeric labels \n"
18612                 "\n"
18613                 "DESCRIPTION:\n"
18614                 "\n"
18615                 "    Sets the number of places after the decimal point in numeric labels. \n"
18616                 "\n"
18617                 "    Redacted form: plprec(setp, prec)\n"
18618                 "\n"
18619                 "    This function is used in example 29. \n"
18620                 "\n"
18621                 "\n"
18622                 "\n"
18623                 "SYNOPSIS:\n"
18624                 "\n"
18625                 "plprec(setp, prec)\n"
18626                 "\n"
18627                 "ARGUMENTS:\n"
18628                 "\n"
18629                 "    setp (PLINT, input) :    If setp is equal to 0 then PLplot\n"
18630                 "    automatically determines the number of places to use after the\n"
18631                 "    decimal point in numeric labels (like those used to label axes). \n"
18632                 "    If setp is 1 then prec sets the number of places. \n"
18633                 "\n"
18634                 "    prec (PLINT, input) :    The number of characters to draw after the\n"
18635                 "    decimal point in numeric labels. \n"
18636                 "\n"
18637                 ""},
18638          { (char *)"plpsty", _wrap_plpsty, METH_VARARGS, (char *)"\n"
18639                 "Select area fill pattern \n"
18640                 "\n"
18641                 "DESCRIPTION:\n"
18642                 "\n"
18643                 "    Select one of eight predefined area fill patterns to use (also see\n"
18644                 "    plpat). Setting the fill style to 0 gives a solid fill. \n"
18645                 "\n"
18646                 "    Redacted form: plpsty(patt)\n"
18647                 "\n"
18648                 "    This function is used in examples 12,13,15,16,25. \n"
18649                 "\n"
18650                 "\n"
18651                 "\n"
18652                 "SYNOPSIS:\n"
18653                 "\n"
18654                 "plpsty(patt)\n"
18655                 "\n"
18656                 "ARGUMENTS:\n"
18657                 "\n"
18658                 "    patt (PLINT, input) :    The desired pattern. Pattern 1 consists of\n"
18659                 "    horizontal lines, pattern 2 consists of vertical lines, pattern 3\n"
18660                 "    consists of lines at 45 degrees angle (upward), and so on. \n"
18661                 "\n"
18662                 ""},
18663          { (char *)"plptex", _wrap_plptex, METH_VARARGS, (char *)"\n"
18664                 "Write text inside the viewport \n"
18665                 "\n"
18666                 "DESCRIPTION:\n"
18667                 "\n"
18668                 "    Writes text at a specified position and inclination within the\n"
18669                 "    viewport.  Text is clipped at the viewport boundaries.  The reference\n"
18670                 "    point of a string lies along a line passing through the string at half\n"
18671                 "    the height of a capital letter.  The position of the reference point\n"
18672                 "    along this line is determined by just, the reference point is placed\n"
18673                 "    at world coordinates (\n"
18674                 "    x, \n"
18675                 "    y) within the viewport.  The inclination of the string is specified in\n"
18676                 "    terms of differences of world coordinates making it easy to write text\n"
18677                 "    parallel to a line in a graph. \n"
18678                 "\n"
18679                 "    Redacted form: plptex(x, y, dx, dy, just, text)\n"
18680                 "\n"
18681                 "    This function is used in example 2-4,10,12-14,20,23,24,26. \n"
18682                 "\n"
18683                 "\n"
18684                 "\n"
18685                 "SYNOPSIS:\n"
18686                 "\n"
18687                 "plptex(x, y, dx, dy, just, text)\n"
18688                 "\n"
18689                 "ARGUMENTS:\n"
18690                 "\n"
18691                 "    x (PLFLT, input) :      x coordinate of reference point of string. \n"
18692                 "\n"
18693                 "    y (PLFLT, input) :      y coordinate of reference point of string. \n"
18694                 "\n"
18695                 "    dx (PLFLT, input) :    Together with dy, this specifies the\n"
18696                 "    inclination of the string.  The baseline of the string is parallel\n"
18697                 "    to a line joining (\n"
18698                 "    x, \n"
18699                 "    y) to (\n"
18700                 "    x+\n"
18701                 "    dx, \n"
18702                 "    y+\n"
18703                 "    dy). \n"
18704                 "\n"
18705                 "    dy (PLFLT, input) :    Together with dx, this specifies the\n"
18706                 "    inclination of the string. \n"
18707                 "\n"
18708                 "    just (PLFLT, input) :    Specifies the position of the string relative\n"
18709                 "    to its reference point.  If just=0., the reference point is at the\n"
18710                 "    left and if just=1., it is at the right of the string.    Other\n"
18711                 "    values of just give intermediate justifications. \n"
18712                 "\n"
18713                 "    text (const char *, input) :    The string to be written out. \n"
18714                 "\n"
18715                 ""},
18716          { (char *)"plptex3", _wrap_plptex3, METH_VARARGS, (char *)"\n"
18717                 "Write text inside the viewport of a 3D plot \n"
18718                 "\n"
18719                 "DESCRIPTION:\n"
18720                 "\n"
18721                 "    Writes text at a specified position and inclination and with a\n"
18722                 "    specified shear within the viewport.  Text is clipped at the viewport\n"
18723                 "    boundaries.  The reference point of a string lies along a line passing\n"
18724                 "    through the string at half the height of a capital letter. The\n"
18725                 "    position of the reference point along this line is determined by just,\n"
18726                 "    and the reference point is placed at world coordinates (\n"
18727                 "    wx, \n"
18728                 "    wy, \n"
18729                 "    wz) within the viewport. The inclination and shear of the string is\n"
18730                 "    specified in terms of differences of world coordinates making it easy\n"
18731                 "    to write text parallel to a line in a graph. \n"
18732                 "\n"
18733                 "    Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz,  just, text)\n"
18734                 "\n"
18735                 "    This function is used in example 28. \n"
18736                 "\n"
18737                 "\n"
18738                 "\n"
18739                 "SYNOPSIS:\n"
18740                 "\n"
18741                 "plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n"
18742                 "\n"
18743                 "ARGUMENTS:\n"
18744                 "\n"
18745                 "    wx (PLFLT, input) :    x world coordinate of reference point of\n"
18746                 "    string. \n"
18747                 "\n"
18748                 "    wy (PLFLT, input) :    y world coordinate of reference point of\n"
18749                 "    string. \n"
18750                 "\n"
18751                 "    wz (PLFLT, input) :    z world coordinate of reference point of\n"
18752                 "    string. \n"
18753                 "\n"
18754                 "    dx (PLFLT, input) :    Together with dy and \n"
18755                 "    dz, this specifies the inclination of  the string.    The baseline of\n"
18756                 "    the string is parallel to a line  joining (\n"
18757                 "    x, \n"
18758                 "    y, \n"
18759                 "    z) to (\n"
18760                 "    x+\n"
18761                 "    dx, \n"
18762                 "    y+\n"
18763                 "    dy, \n"
18764                 "    z+\n"
18765                 "    dz). \n"
18766                 "\n"
18767                 "    dy (PLFLT, input) :    Together with dx and \n"
18768                 "    dz, this specifies the inclination of the string. \n"
18769                 "\n"
18770                 "    dz (PLFLT, input) :    Together with dx and \n"
18771                 "    dy, this specifies the inclination of the string. \n"
18772                 "\n"
18773                 "    sx (PLFLT, input) :    Together with sy and \n"
18774                 "    sz, this specifies the shear of  the string.  The string is sheared so\n"
18775                 "    that the characters are  vertically parallel to a line joining (\n"
18776                 "    x, \n"
18777                 "    y, \n"
18778                 "    z) to (\n"
18779                 "    x+\n"
18780                 "    sx, \n"
18781                 "    y+\n"
18782                 "    sy, \n"
18783                 "    z+\n"
18784                 "    sz). If sx = \n"
18785                 "    sy = \n"
18786                 "    sz = 0.) then the text is not sheared. \n"
18787                 "\n"
18788                 "    sy (PLFLT, input) :    Together with sx and \n"
18789                 "    sz, this specifies shear of the string. \n"
18790                 "\n"
18791                 "    sz (PLFLT, input) :    Together with sx and \n"
18792                 "    sy, this specifies shear of the string. \n"
18793                 "\n"
18794                 "    just (PLFLT, input) :    Specifies the position of the string relative\n"
18795                 "    to its reference point.  If just=0., the reference point is at the\n"
18796                 "    left and if just=1., it is at the right of the string.    Other\n"
18797                 "    values of just give intermediate justifications. \n"
18798                 "\n"
18799                 "    text (const char *, input) :    The string to be written out. \n"
18800                 "\n"
18801                 ""},
18802          { (char *)"plrandd", _wrap_plrandd, METH_VARARGS, (char *)"\n"
18803                 "Random number generator  returning a real random number in the range [0,1] \n"
18804                 "\n"
18805                 "DESCRIPTION:\n"
18806                 "\n"
18807                 "    Random number generator returning a real random number in the  range\n"
18808                 "    [0,1]. The generator is based on the Mersenne Twister.  Most languages\n"
18809                 "    / compilers provide their own random number generator,  and so this is\n"
18810                 "    provided purely for convenience and to give a consistent random number\n"
18811                 "    generator across all languages supported  by PLplot. This is\n"
18812                 "    particularly useful for comparing results  from the test suite of\n"
18813                 "    examples. \n"
18814                 "\n"
18815                 "    Redacted form: plrandd()\n"
18816                 "\n"
18817                 "    This function is used in examples 17,21. \n"
18818                 "\n"
18819                 "\n"
18820                 "\n"
18821                 "SYNOPSIS:\n"
18822                 "\n"
18823                 "plrandd()\n"
18824                 "\n"
18825                 ""},
18826          { (char *)"plreplot", _wrap_plreplot, METH_VARARGS, (char *)"\n"
18827                 "Replays contents of plot buffer to current device/file \n"
18828                 "\n"
18829                 "DESCRIPTION:\n"
18830                 "\n"
18831                 "    Replays contents of plot buffer to current device/file. \n"
18832                 "\n"
18833                 "    Redacted form: plreplot()\n"
18834                 "\n"
18835                 "    This function is used in example 1,20. \n"
18836                 "\n"
18837                 "\n"
18838                 "\n"
18839                 "SYNOPSIS:\n"
18840                 "\n"
18841                 "plreplot()\n"
18842                 "\n"
18843                 ""},
18844          { (char *)"plrgbhls", _wrap_plrgbhls, METH_VARARGS, (char *)"\n"
18845                 "Convert RGB color to HLS \n"
18846                 "\n"
18847                 "DESCRIPTION:\n"
18848                 "\n"
18849                 "    Convert RGB color coordinates to HLS \n"
18850                 "\n"
18851                 "    Redacted form:  General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
18852                 "           Perl/PDL: Not available? Implemented as plrgb/plrgb1? \n"
18853                 "\n"
18854                 "\n"
18855                 "    This function is used in example 2. \n"
18856                 "\n"
18857                 "\n"
18858                 "\n"
18859                 "SYNOPSIS:\n"
18860                 "\n"
18861                 "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
18862                 "\n"
18863                 "ARGUMENTS:\n"
18864                 "\n"
18865                 "    r (PLFLT, input) :      Red intensity (0.0-1.0) of the colour \n"
18866                 "\n"
18867                 "    g (PLFLT, input) :      Green intensity (0.0-1.0) of the colour \n"
18868                 "\n"
18869                 "    b (PLFLT, input) :      Blue intensity (0.0-1.0) of the colour \n"
18870                 "\n"
18871                 "    p_h (PLFLT *, output) :    Pointer to hue, in degrees on the colour\n"
18872                 "    cone (0.0-360.0) \n"
18873                 "\n"
18874                 "    p_l (PLFLT *, output) :    Pointer to lightness, expressed as a\n"
18875                 "    fraction of the axis of the colour cone (0.0-1.0) \n"
18876                 "\n"
18877                 "    p_s (PLFLT *, output) :    Pointer to saturation, expressed as a\n"
18878                 "    fraction of the radius of the colour cone (0.0-1.0) \n"
18879                 "\n"
18880                 ""},
18881          { (char *)"plschr", _wrap_plschr, METH_VARARGS, (char *)"\n"
18882                 "Set character size \n"
18883                 "\n"
18884                 "DESCRIPTION:\n"
18885                 "\n"
18886                 "    This sets up the size of all subsequent characters drawn.  The actual\n"
18887                 "    height of a character is the product of the default character size and\n"
18888                 "    a scaling factor. \n"
18889                 "\n"
18890                 "    Redacted form: plschr(def, scale)\n"
18891                 "\n"
18892                 "    This function is used in example 2,13,23,24. \n"
18893                 "\n"
18894                 "\n"
18895                 "\n"
18896                 "SYNOPSIS:\n"
18897                 "\n"
18898                 "plschr(def, scale)\n"
18899                 "\n"
18900                 "ARGUMENTS:\n"
18901                 "\n"
18902                 "    def (PLFLT, input) :    The default height of a character in\n"
18903                 "    millimeters, should be set to zero if the default height is to\n"
18904                 "    remain unchanged. \n"
18905                 "\n"
18906                 "    scale (PLFLT, input) :    Scale factor to be applied to default to get\n"
18907                 "    actual character height. \n"
18908                 "\n"
18909                 ""},
18910          { (char *)"plscmap0", _wrap_plscmap0, METH_VARARGS, (char *)"\n"
18911                 "Set cmap0 colors by 8-bit RGB values \n"
18912                 "\n"
18913                 "DESCRIPTION:\n"
18914                 "\n"
18915                 "    Set cmap0 colors using 8-bit RGB values (see the PLplot\n"
18916                 "    documentation).  This sets the entire color map -- only as many colors\n"
18917                 "    as specified will be allocated. \n"
18918                 "\n"
18919                 "    Redacted form: plscmap0(r, g, b)\n"
18920                 "\n"
18921                 "    This function is used in examples 2,24. \n"
18922                 "\n"
18923                 "\n"
18924                 "\n"
18925                 "SYNOPSIS:\n"
18926                 "\n"
18927                 "plscmap0(r, g, b, ncol0)\n"
18928                 "\n"
18929                 "ARGUMENTS:\n"
18930                 "\n"
18931                 "    r (const PLINT *, input) :      Pointer to array with set of unsigned\n"
18932                 "    8-bit integers (0-255) representing the degree of red in the\n"
18933                 "    color. \n"
18934                 "\n"
18935                 "    g (const PLINT *, input) :      Pointer to array with set of unsigned\n"
18936                 "    8-bit integers (0-255) representing the degree of green in the\n"
18937                 "    color. \n"
18938                 "\n"
18939                 "    b (const PLINT *, input) :      Pointer to array with set of unsigned\n"
18940                 "    8-bit integers (0-255) representing the degree of blue in the\n"
18941                 "    color. \n"
18942                 "\n"
18943                 "    ncol0 (PLINT, input) :    Number of items in the r, g, and b arrays. \n"
18944                 "\n"
18945                 ""},
18946          { (char *)"plscmap0a", _wrap_plscmap0a, METH_VARARGS, (char *)"\n"
18947                 "Set cmap0 colors by 8-bit RGB values and  double alpha transparency value \n"
18948                 "\n"
18949                 "DESCRIPTION:\n"
18950                 "\n"
18951                 "    Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n"
18952                 "     and floating point alpha transparency value.  This sets the entire\n"
18953                 "    color map -- only as many colors as specified will be allocated. \n"
18954                 "\n"
18955                 "    Redacted form: plscmap0a(r, g, b, alpha)\n"
18956                 "\n"
18957                 "    This function is used in examples 30. \n"
18958                 "\n"
18959                 "\n"
18960                 "\n"
18961                 "SYNOPSIS:\n"
18962                 "\n"
18963                 "plscmap0a(r, g, b, alpha, ncol0)\n"
18964                 "\n"
18965                 "ARGUMENTS:\n"
18966                 "\n"
18967                 "    r (const PLINT *, input) :      Pointer to array with set of unsigned\n"
18968                 "    8-bit integers (0-255) representing the degree of red in the\n"
18969                 "    color. \n"
18970                 "\n"
18971                 "    g (const PLINT *, input) :      Pointer to array with set of unsigned\n"
18972                 "    8-bit integers (0-255) representing the degree of green in the\n"
18973                 "    color. \n"
18974                 "\n"
18975                 "    b (const PLINT *, input) :      Pointer to array with set of unsigned\n"
18976                 "    8-bit integers (0-255) representing the degree of blue in the\n"
18977                 "    color. \n"
18978                 "\n"
18979                 "    alpha (const PLFLT *, input) :    Pointer to array with set of PLFLT\n"
18980                 "    values (0.0 - 1.0) representing the alpha transparency of the\n"
18981                 "    color. \n"
18982                 "\n"
18983                 "    ncol0 (PLINT, input) :    Number of items in the r, g, b, and alpha\n"
18984                 "    arrays. \n"
18985                 "\n"
18986                 ""},
18987          { (char *)"plscmap0n", _wrap_plscmap0n, METH_VARARGS, (char *)"\n"
18988                 "Set number of colors in cmap0 \n"
18989                 "\n"
18990                 "DESCRIPTION:\n"
18991                 "\n"
18992                 "    Set number of colors in color map0 (see the PLplot documentation).\n"
18993                 "    Allocate (or reallocate) color map0, and fill with default values for\n"
18994                 "    those colors not previously allocated. The first 16 default colors are\n"
18995                 "    given in the plcol0 documentation. For larger indices the default\n"
18996                 "    color is red. \n"
18997                 "\n"
18998                 "    The drivers are not guaranteed to support more than 16 colors. \n"
18999                 "\n"
19000                 "    Redacted form: plscmap0n(ncol0)\n"
19001                 "\n"
19002                 "    This function is used in examples 15,16,24. \n"
19003                 "\n"
19004                 "\n"
19005                 "\n"
19006                 "SYNOPSIS:\n"
19007                 "\n"
19008                 "plscmap0n(ncol0)\n"
19009                 "\n"
19010                 "ARGUMENTS:\n"
19011                 "\n"
19012                 "    ncol0 (PLINT, input) :    Number of colors that will be allocated in\n"
19013                 "    the map0 palette. If this number is zero or less, then the value\n"
19014                 "    from the previous call to plscmap0n is used and if there is no\n"
19015                 "    previous call, then a default value is used. \n"
19016                 "\n"
19017                 ""},
19018          { (char *)"plscmap1", _wrap_plscmap1, METH_VARARGS, (char *)"\n"
19019                 "Set cmap1 colors using 8-bit RGB values \n"
19020                 "\n"
19021                 "DESCRIPTION:\n"
19022                 "\n"
19023                 "    Set cmap1 colors using 8-bit RGB values (see the PLplot\n"
19024                 "    documentation).  This also sets the number of colors. \n"
19025                 "\n"
19026                 "    Redacted form: plscmap1(r, g, b)\n"
19027                 "\n"
19028                 "    This function is used in example 31. \n"
19029                 "\n"
19030                 "\n"
19031                 "\n"
19032                 "SYNOPSIS:\n"
19033                 "\n"
19034                 "plscmap1(r, g, b, ncol1)\n"
19035                 "\n"
19036                 "ARGUMENTS:\n"
19037                 "\n"
19038                 "    r (const PLINT *, input) :      Pointer to array with set of unsigned\n"
19039                 "    8-bit integers (0-255) representing the degree of red in the\n"
19040                 "    color. \n"
19041                 "\n"
19042                 "    g (const PLINT *, input) :      Pointer to array with set of unsigned\n"
19043                 "    8-bit integers (0-255) representing the degree of green in the\n"
19044                 "    color. \n"
19045                 "\n"
19046                 "    b (const PLINT *, input) :      Pointer to array with set of unsigned\n"
19047                 "    8-bit integers (0-255) representing the degree of blue in the\n"
19048                 "    color. \n"
19049                 "\n"
19050                 "    ncol1 (PLINT, input) :    Number of items in the r, g, and b arrays. \n"
19051                 "\n"
19052                 ""},
19053          { (char *)"plscmap1a", _wrap_plscmap1a, METH_VARARGS, (char *)"\n"
19054                 "Set cmap1 colors using 8-bit RGB values and double alpha transparency values \n"
19055                 "\n"
19056                 "DESCRIPTION:\n"
19057                 "\n"
19058                 "    Set cmap1 colors using 8-bit RGB values (see the PLplot documentation)\n"
19059                 "    and double alpha transparency values. This also sets the number of\n"
19060                 "    colors.\n"
19061                 "\n"
19062                 "    Redacted form: plscmap1a(r, g, b, alpha)\n"
19063                 "\n"
19064                 "    This function is used in example 31. \n"
19065                 "\n"
19066                 "\n"
19067                 "\n"
19068                 "SYNOPSIS:\n"
19069                 "\n"
19070                 "plscmap1a(r, g, b, alpha, ncol1)\n"
19071                 "\n"
19072                 "ARGUMENTS:\n"
19073                 "\n"
19074                 "    r (const PLINT *, input) :      Pointer to array with set of unsigned\n"
19075                 "    8-bit integers (0-255) representing the degree of red in the\n"
19076                 "    color. \n"
19077                 "\n"
19078                 "    g (const PLINT *, input) :      Pointer to array with set of unsigned\n"
19079                 "    8-bit integers (0-255) representing the degree of green in the\n"
19080                 "    color. \n"
19081                 "\n"
19082                 "    b (const PLINT *, input) :      Pointer to array with set of unsigned\n"
19083                 "    8-bit integers (0-255) representing the degree of blue in the\n"
19084                 "    color. \n"
19085                 "\n"
19086                 "    alpha (const PLFLT *, input) :    Pointer to array with set of double\n"
19087                 "    values (0.0-1.0) representing the alpha transparency value of the\n"
19088                 "    color. \n"
19089                 "\n"
19090                 "    ncol1 (PLINT, input) :    Number of items in the r, g, b, and alpha\n"
19091                 "    arrays. \n"
19092                 "\n"
19093                 ""},
19094          { (char *)"plscmap1l", _wrap_plscmap1l, METH_VARARGS, (char *)"\n"
19095                 "Set cmap1 colors using a piece-wise linear relationship \n"
19096                 "\n"
19097                 "DESCRIPTION:\n"
19098                 "\n"
19099                 "    Set cmap1 colors using a piece-wise linear relationship between\n"
19100                 "    intensity index (from 0. to 1.) of cmap1 and position in HLS or RGB\n"
19101                 "    color space (see the PLplot documentation).  May be called at any\n"
19102                 "    time. \n"
19103                 "\n"
19104                 "    The idea here is to specify a number of control points that define the\n"
19105                 "    mapping between input cmap1 intensity indices and  HLS (or RGB). \n"
19106                 "    Between these points, linear interpolation is used which gives a\n"
19107                 "    smooth variation of color with intensity index.  Any number of control\n"
19108                 "    points may be specified, located at arbitrary positions, although\n"
19109                 "    typically 2 - 4 are enough. Another way of stating this is that we are\n"
19110                 "    traversing a given number of lines through HLS (or RGB) space as we\n"
19111                 "    move through cmap1 intensity indices.  The control points at the\n"
19112                 "    minimum and maximum position (0 and 1) must always be specified.  By\n"
19113                 "    adding more control points you can get more variation.  One good\n"
19114                 "    technique for plotting functions that vary about some expected average\n"
19115                 "    is to use an additional 2 control points in the center (position ~=\n"
19116                 "    0.5) that are the same lightness as the background (typically white\n"
19117                 "    for paper output, black for crt), and same hue as the boundary control\n"
19118                 "    points.  This allows the highs and lows to be very easily\n"
19119                 "    distinguished. \n"
19120                 "\n"
19121                 "    Each control point must specify the cmap1 intensity index and the\n"
19122                 "    associated three coordinates in HLS or RGB space.  The first point\n"
19123                 "    must correspond to position = 0, and the last to position = 1. \n"
19124                 "\n"
19125                 "    The default behaviour is for the hue to be linearly interpolated \n"
19126                 "    between the control points. Since the hue lies in the range [0, 360]\n"
19127                 "    this corresponds to interpolation around the \"front\" of the color\n"
19128                 "    wheel (red<->green<->blue<->red). If alt_hue_path[i] is true, then an\n"
19129                 "    alternative interpolation is used between control points i and i+1. If\n"
19130                 "     hue[i+1]-hue[i] > 0 then interpolation is between hue[i] and\n"
19131                 "    hue[i+1] - 360, otherwise  between hue[i] and hue[i+1] + 360.  You can\n"
19132                 "    consider this as interpolation around the \"back\" or \"reverse\" of  the\n"
19133                 "    color wheel. Specifying alt_hue_path=NULL is equivalent to setting\n"
19134                 "    alt_hue_path[] = false for every control point.  \n"
19135                 "\n"
19136                 "    Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
19137                 "    240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
19138                 "    240]truegreen-yellow-red-magenta-blue[240\n"
19139                 "    120]trueblue-magenta-red-yellow-green\n"
19140                 "\n"
19141                 "    Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
19142                 "    1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
19143                 "    1]magnitudeHLSsaturation[0, 1]magnitude\n"
19144                 "\n"
19145                 "    Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n"
19146                 "    alt_hue_path)\n"
19147                 "\n"
19148                 "    This function is used in examples 8,11,12,15,20,21. \n"
19149                 "\n"
19150                 "\n"
19151                 "\n"
19152                 "SYNOPSIS:\n"
19153                 "\n"
19154                 "plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n"
19155                 "\n"
19156                 "ARGUMENTS:\n"
19157                 "\n"
19158                 "    itype (PLBOOL, input) :    true: RGB, false: HLS. \n"
19159                 "\n"
19160                 "    npts (PLINT, input) :    number of control points \n"
19161                 "\n"
19162                 "    intensity (const PLFLT *, input) :      intensity index for each control\n"
19163                 "    point (between 0.0 and 1.0, in ascending order) \n"
19164                 "\n"
19165                 "    coord1 (const PLFLT *, input) :    first coordinate (H or R) for each\n"
19166                 "    control point \n"
19167                 "\n"
19168                 "    coord2 (const PLFLT *, input) :    second coordinate (L or G) for each\n"
19169                 "    control point \n"
19170                 "\n"
19171                 "    coord3 (const PLFLT *, input) :    third coordinate (S or B) for each\n"
19172                 "    control point \n"
19173                 "\n"
19174                 "    alt_hue_path (const PLBOOL *, input) :    alternative interpolation\n"
19175                 "    method flag for each control point.  (alt_hue_path[i] refers to\n"
19176                 "    the interpolation interval between the i and i + 1 control\n"
19177                 "    points). \n"
19178                 "\n"
19179                 ""},
19180          { (char *)"plscmap1la", _wrap_plscmap1la, METH_VARARGS, (char *)"\n"
19181                 "Set cmap1 colors and alpha transparency using a piece-wise linear relationship \n"
19182                 "\n"
19183                 "DESCRIPTION:\n"
19184                 "\n"
19185                 "    This is a variant of plscmap1l that supports alpha channel\n"
19186                 "    transparency. It sets cmap1 colors using a piece-wise linear\n"
19187                 "    relationship between cmap1 intensity index (from 0. to 1.) and\n"
19188                 "    position in HLS or RGB color space (see the PLplot documentation) with\n"
19189                 "    alpha transparency value  (0.0 - 1.0). It may be called at any time. \n"
19190                 "\n"
19191                 "    Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n"
19192                 "    alpha, alt_hue_path)\n"
19193                 "\n"
19194                 "    This function is used in example 30. \n"
19195                 "\n"
19196                 "\n"
19197                 "\n"
19198                 "SYNOPSIS:\n"
19199                 "\n"
19200                 "plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n"
19201                 "\n"
19202                 "ARGUMENTS:\n"
19203                 "\n"
19204                 "    itype (PLBOOL, input) :    true: RGB, false: HLS. \n"
19205                 "\n"
19206                 "    npts (PLINT, input) :    number of control points \n"
19207                 "\n"
19208                 "    intensity (const PLFLT *, input) :      position for each control point\n"
19209                 "    (between 0.0 and 1.0, in ascending order) \n"
19210                 "\n"
19211                 "    coord1 (const PLFLT *, input) :    first coordinate (H or R) for each\n"
19212                 "    control point \n"
19213                 "\n"
19214                 "    coord2 (const PLFLT *, input) :    second coordinate (L or G) for each\n"
19215                 "    control point \n"
19216                 "\n"
19217                 "    coord3 (const PLFLT *, input) :    third coordinate (S or B) for each\n"
19218                 "    control point \n"
19219                 "\n"
19220                 "    alpha (const PLFLT *, input) :    the alpha transparency value for\n"
19221                 "    each control point \n"
19222                 "\n"
19223                 "    alt_hue_path (const PLBOOL *, input) :    alternative interpolation\n"
19224                 "    method flag for each control point.  (alt_hue_path[i] refers to\n"
19225                 "    the interpolation interval between the i and i + 1 control\n"
19226                 "    points). \n"
19227                 "\n"
19228                 ""},
19229          { (char *)"plscmap1n", _wrap_plscmap1n, METH_VARARGS, (char *)"\n"
19230                 "Set number of colors in cmap1 \n"
19231                 "\n"
19232                 "DESCRIPTION:\n"
19233                 "\n"
19234                 "    Set number of colors in cmap1, (re-)allocate color map1, and set\n"
19235                 "    default values if this is the first allocation (see the PLplot\n"
19236                 "    documentation). \n"
19237                 "\n"
19238                 "    Redacted form: plscmap1n(ncol1)\n"
19239                 "\n"
19240                 "    This function is used in examples 8,11,20,21. \n"
19241                 "\n"
19242                 "\n"
19243                 "\n"
19244                 "SYNOPSIS:\n"
19245                 "\n"
19246                 "plscmap1n(ncol1)\n"
19247                 "\n"
19248                 "ARGUMENTS:\n"
19249                 "\n"
19250                 "    ncol1 (PLINT, input) :    Number of colors that will be allocated in\n"
19251                 "    the map1 palette. If this number is zero or less, then the value\n"
19252                 "    from the previous call to plscmap1n is used and if there is no\n"
19253                 "    previous call, then a default value is used. \n"
19254                 "\n"
19255                 ""},
19256          { (char *)"plscmap1_range", _wrap_plscmap1_range, METH_VARARGS, (char *)"\n"
19257                 "Set the cmap1 argument range for continuous color plots \n"
19258                 "\n"
19259                 "DESCRIPTION:\n"
19260                 "\n"
19261                 "    Set the cmap1 argument range for continuous color plots. If \n"
19262                 "    min_color is greater than \n"
19263                 "    max_color or \n"
19264                 "    max_color is greater than 1.0 or \n"
19265                 "    min_color is less than 0.0 then no change is made. (Use\n"
19266                 "    plgcmap1_range to get the cmap1 argument range.) \n"
19267                 "\n"
19268                 "    Redacted form: plscmap1_range(min_color, max_color)\n"
19269                 "\n"
19270                 "    This function is currently used in example 33. \n"
19271                 "\n"
19272                 "\n"
19273                 "\n"
19274                 "SYNOPSIS:\n"
19275                 "\n"
19276                 "plscmap1_range(min_color, max_color)\n"
19277                 "\n"
19278                 "ARGUMENTS:\n"
19279                 "\n"
19280                 "    min_color (PLFLT, input) :      The minimum cmap1 floating point\n"
19281                 "    argument. \n"
19282                 "\n"
19283                 "    max_color (PLFLT, input) :      The maximum cmap1 floating point\n"
19284                 "    argument. \n"
19285                 "\n"
19286                 ""},
19287          { (char *)"plgcmap1_range", _wrap_plgcmap1_range, METH_VARARGS, (char *)"\n"
19288                 "Get the cmap1 argument range for continuous color plots \n"
19289                 "\n"
19290                 "DESCRIPTION:\n"
19291                 "\n"
19292                 "    Get the cmap1 argument range for continuous color plots. (Use\n"
19293                 "    plgsmap1_range to set the cmap1 argument range.) \n"
19294                 "\n"
19295                 "    Redacted form: plgcmap1_range(min_color, max_color)\n"
19296                 "\n"
19297                 "    This function is currently not used in any example. \n"
19298                 "\n"
19299                 "\n"
19300                 "\n"
19301                 "SYNOPSIS:\n"
19302                 "\n"
19303                 "plgcmap1_range(min_color, max_color)\n"
19304                 "\n"
19305                 "ARGUMENTS:\n"
19306                 "\n"
19307                 "    min_color (PLFLT *, output) :    Pointer to the current minimum cmap1\n"
19308                 "    floating point argument. \n"
19309                 "\n"
19310                 "    max_color (PLFLT *, output) :    Pointer to the current maximum cmap1\n"
19311                 "    floating point argument. \n"
19312                 "\n"
19313                 ""},
19314          { (char *)"plscol0", _wrap_plscol0, METH_VARARGS, (char *)"\n"
19315                 "Set 8-bit RGB values for given cmap0 color index \n"
19316                 "\n"
19317                 "ESCRIPTION:\n"
19318                 "\n"
19319                 "   Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n"
19320                 "   index.  Overwrites the previous color value for the given index and,\n"
19321                 "   thus, does not result in any additional allocation of space for\n"
19322                 "   colors. \n"
19323                 "\n"
19324                 "   Redacted form: plscol0(icol0, r, g, b)\n"
19325                 "\n"
19326                 "   This function is used in any example 31. \n"
19327                 "\n"
19328                 "\n"
19329                 "\n"
19330                 "YNOPSIS:\n"
19331                 "\n"
19332                 "lscol0(icol0, r, g, b)\n"
19333                 "\n"
19334                 "RGUMENTS:\n"
19335                 "\n"
19336                 "   icol0 (PLINT, input) :    Color index.  Must be less than the maximum\n"
19337                 "   number of colors (which is set by default, by plscmap0n, or even\n"
19338                 "   by plscmap0). \n"
19339                 "\n"
19340                 "   r (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
19341                 "   degree of red in the color. \n"
19342                 "\n"
19343                 "   g (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
19344                 "   degree of green in the color. \n"
19345                 "\n"
19346                 "   b (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
19347                 "   degree of blue in the color. \n"
19348                 "\n"
19349                 ""},
19350          { (char *)"plscol0a", _wrap_plscol0a, METH_VARARGS, (char *)"\n"
19351                 "Set 8-bit  RGB values and double alpha transparency value for given cmap0 color index \n"
19352                 "\n"
19353                 "ESCRIPTION:\n"
19354                 "\n"
19355                 "   Set 8-bit RGB value and double alpha transparency value for given\n"
19356                 "   cmap0 (see the PLplot documentation) index.  Overwrites the previous\n"
19357                 "   color value  for the given index and, thus, does not result in any\n"
19358                 "   additional allocation  of space for colors. \n"
19359                 "\n"
19360                 "   This function is used in example 30. \n"
19361                 "\n"
19362                 "\n"
19363                 "\n"
19364                 "YNOPSIS:\n"
19365                 "\n"
19366                 "lscol0a(icol0, r, g, b, alpha)\n"
19367                 "\n"
19368                 "RGUMENTS:\n"
19369                 "\n"
19370                 "   icol0 (PLINT, input) :    Color index.  Must be less than the maximum\n"
19371                 "   number of colors (which is set by default, by plscmap0n, or even\n"
19372                 "   by plscmap0). \n"
19373                 "\n"
19374                 "   r (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
19375                 "   degree of red in the color. \n"
19376                 "\n"
19377                 "   g (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
19378                 "   degree of green in the color. \n"
19379                 "\n"
19380                 "   b (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
19381                 "   degree of blue in the color. \n"
19382                 "\n"
19383                 "   alpha (PLFLT, input) :    double value (0.0-1.0) representing the\n"
19384                 "   alpha transparency value of the color. \n"
19385                 "\n"
19386                 ""},
19387          { (char *)"plscolbg", _wrap_plscolbg, METH_VARARGS, (char *)"\n"
19388                 "Set the background color by 8-bit RGB value \n"
19389                 "\n"
19390                 "DESCRIPTION:\n"
19391                 "\n"
19392                 "    Set the background color (color 0 in color map 0) by 8-bit RGB value\n"
19393                 "    (see the PLplot documentation). \n"
19394                 "\n"
19395                 "    Redacted form: plscolbg(r, g, b)\n"
19396                 "\n"
19397                 "    This function is used in examples 15,31. \n"
19398                 "\n"
19399                 "\n"
19400                 "\n"
19401                 "SYNOPSIS:\n"
19402                 "\n"
19403                 "plscolbg(r, g, b)\n"
19404                 "\n"
19405                 "ARGUMENTS:\n"
19406                 "\n"
19407                 "    r (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
19408                 "    degree of red in the color. \n"
19409                 "\n"
19410                 "    g (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
19411                 "    degree of green in the color. \n"
19412                 "\n"
19413                 "    b (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
19414                 "    degree of blue in the color. \n"
19415                 "\n"
19416                 ""},
19417          { (char *)"plscolbga", _wrap_plscolbga, METH_VARARGS, (char *)"\n"
19418                 "Set the background color by 8-bit RGB value and double alpha transparency value. \n"
19419                 "\n"
19420                 "DESCRIPTION:\n"
19421                 "\n"
19422                 "    Set the background color (color 0 in color map 0) by 8-bit RGB value\n"
19423                 "    (see the PLplot documentation) and double alpha transparency value. \n"
19424                 "\n"
19425                 "    This function is used in example 31. \n"
19426                 "\n"
19427                 "\n"
19428                 "\n"
19429                 "SYNOPSIS:\n"
19430                 "\n"
19431                 "plscolbga(r, g, b, alpha)\n"
19432                 "\n"
19433                 "ARGUMENTS:\n"
19434                 "\n"
19435                 "    r (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
19436                 "    degree of red in the color. \n"
19437                 "\n"
19438                 "    g (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
19439                 "    degree of green in the color. \n"
19440                 "\n"
19441                 "    b (PLINT, input) :      Unsigned 8-bit integer (0-255) representing the\n"
19442                 "    degree of blue in the color. \n"
19443                 "\n"
19444                 "    alpha (PLFLT, input) :    double value (0.0-1.0) representing the\n"
19445                 "    alpha transparency value of the color. \n"
19446                 "\n"
19447                 ""},
19448          { (char *)"plscolor", _wrap_plscolor, METH_VARARGS, (char *)"\n"
19449                 "Used to globally turn color output on/off \n"
19450                 "\n"
19451                 "DESCRIPTION:\n"
19452                 "\n"
19453                 "    Used to globally turn color output on/off for those drivers/devices\n"
19454                 "    that support it. \n"
19455                 "\n"
19456                 "    Redacted form: plscolor(color)\n"
19457                 "\n"
19458                 "    This function is used in example 31. \n"
19459                 "\n"
19460                 "\n"
19461                 "\n"
19462                 "SYNOPSIS:\n"
19463                 "\n"
19464                 "plscolor(color)\n"
19465                 "\n"
19466                 "ARGUMENTS:\n"
19467                 "\n"
19468                 "    color (PLINT, input) :    Color flag (Boolean).  If zero, color is\n"
19469                 "    turned off.  If non-zero, color is turned on. \n"
19470                 "\n"
19471                 ""},
19472          { (char *)"plscompression", _wrap_plscompression, METH_VARARGS, (char *)"\n"
19473                 "Set device-compression level \n"
19474                 "\n"
19475                 "DESCRIPTION:\n"
19476                 "\n"
19477                 "    Set device-compression level.  Only used for drivers that provide\n"
19478                 "    compression.  This function, if used, should be invoked before a call\n"
19479                 "    to plinit. \n"
19480                 "\n"
19481                 "    Redacted form: plscompression(compression)\n"
19482                 "\n"
19483                 "    This function is used in example 31. \n"
19484                 "\n"
19485                 "\n"
19486                 "\n"
19487                 "SYNOPSIS:\n"
19488                 "\n"
19489                 "plscompression(compression)\n"
19490                 "\n"
19491                 "ARGUMENTS:\n"
19492                 "\n"
19493                 "    compression (PLINT, input) :    The desired compression level. This is\n"
19494                 "    a device-dependent value. Currently only the jpeg and png devices\n"
19495                 "    use these values. For jpeg  value is the jpeg quality which should\n"
19496                 "    normally be in the range 0-95. Higher values denote higher quality\n"
19497                 "    and hence larger image sizes. For png values are in the range -1\n"
19498                 "    to 99. Values of 0-9 are taken as the  compression level for zlib.\n"
19499                 "    A value of -1 denotes the default zlib    compression level. Values\n"
19500                 "    in the range 10-99 are divided by 10 and  then used as the zlib\n"
19501                 "    compression level. Higher compression levels correspond to greater\n"
19502                 "    compression and small file sizes at the expense of more\n"
19503                 "    computation. \n"
19504                 "\n"
19505                 ""},
19506          { (char *)"plsdev", _wrap_plsdev, METH_VARARGS, (char *)"\n"
19507                 "Set the device (keyword) name \n"
19508                 "\n"
19509                 "DESCRIPTION:\n"
19510                 "\n"
19511                 "    Set the device (keyword) name. \n"
19512                 "\n"
19513                 "    Redacted form: plsdev(devname)\n"
19514                 "\n"
19515                 "    This function is used in examples 1,14,20. \n"
19516                 "\n"
19517                 "\n"
19518                 "\n"
19519                 "SYNOPSIS:\n"
19520                 "\n"
19521                 "plsdev(devname)\n"
19522                 "\n"
19523                 "ARGUMENTS:\n"
19524                 "\n"
19525                 "    devname (const char *, input) :    Pointer to device (keyword) name\n"
19526                 "    string. \n"
19527                 "\n"
19528                 ""},
19529          { (char *)"plsdidev", _wrap_plsdidev, METH_VARARGS, (char *)"\n"
19530                 "Set parameters that define current device-space window \n"
19531                 "\n"
19532                 "DESCRIPTION:\n"
19533                 "\n"
19534                 "    Set relative margin width, aspect ratio, and relative justification\n"
19535                 "    that define current device-space window.  If you want to just use the\n"
19536                 "    previous value for any of these, just pass in the magic value\n"
19537                 "    PL_NOTSET. It is unlikely that one should ever need to change the\n"
19538                 "    aspect ratio but it's in there for completeness. If plsdidev is not\n"
19539                 "    called the default values of mar, jx, and jy are all 0. aspect is set\n"
19540                 "    to a device-specific value. \n"
19541                 "\n"
19542                 "    Redacted form: plsdidev(mar, aspect, jx, jy)\n"
19543                 "\n"
19544                 "    This function is used in example 31. \n"
19545                 "\n"
19546                 "\n"
19547                 "\n"
19548                 "SYNOPSIS:\n"
19549                 "\n"
19550                 "plsdidev(mar, aspect, jx, jy)\n"
19551                 "\n"
19552                 "ARGUMENTS:\n"
19553                 "\n"
19554                 "    mar (PLFLT, input) :    Relative margin width. \n"
19555                 "\n"
19556                 "    aspect (PLFLT, input) :    Aspect ratio. \n"
19557                 "\n"
19558                 "    jx (PLFLT, input) :    Relative justification in x. Value must lie in\n"
19559                 "    the range -0.5 to 0.5. \n"
19560                 "\n"
19561                 "    jy (PLFLT, input) :    Relative justification in y. Value must lie in\n"
19562                 "    the range -0.5 to 0.5. \n"
19563                 "\n"
19564                 ""},
19565          { (char *)"plsdimap", _wrap_plsdimap, METH_VARARGS, (char *)"\n"
19566                 "Set up transformation from metafile coordinates \n"
19567                 "\n"
19568                 "DESCRIPTION:\n"
19569                 "\n"
19570                 "    Set up transformation from metafile coordinates.  The size of the plot\n"
19571                 "    is scaled so as to preserve aspect ratio.  This isn't intended to be a\n"
19572                 "    general-purpose facility just yet (not sure why the user would need\n"
19573                 "    it, for one). \n"
19574                 "\n"
19575                 "    Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
19576                 "    dimypmm)\n"
19577                 "\n"
19578                 "    This function is not used in any examples. \n"
19579                 "\n"
19580                 "\n"
19581                 "\n"
19582                 "SYNOPSIS:\n"
19583                 "\n"
19584                 "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
19585                 "\n"
19586                 "ARGUMENTS:\n"
19587                 "\n"
19588                 "    dimxmin (PLINT, input) :    NEEDS DOCUMENTATION \n"
19589                 "\n"
19590                 "    dimxmax (PLINT, input) :    NEEDS DOCUMENTATION \n"
19591                 "\n"
19592                 "    dimymin (PLINT, input) :    NEEDS DOCUMENTATION \n"
19593                 "\n"
19594                 "    dimymax (PLINT, input) :    NEEDS DOCUMENTATION \n"
19595                 "\n"
19596                 "    dimxpmm (PLFLT, input) :    NEEDS DOCUMENTATION \n"
19597                 "\n"
19598                 "    dimypmm (PLFLT, input) :    NEEDS DOCUMENTATION \n"
19599                 "\n"
19600                 ""},
19601          { (char *)"plsdiori", _wrap_plsdiori, METH_VARARGS, (char *)"\n"
19602                 "Set plot orientation \n"
19603                 "\n"
19604                 "DESCRIPTION:\n"
19605                 "\n"
19606                 "    Set plot orientation parameter which is multiplied by 90 degrees to\n"
19607                 "    obtain the angle of rotation.  Note, arbitrary rotation parameters\n"
19608                 "    such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
19609                 "    values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
19610                 "    to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
19611                 "    (seascape mode), and 270 degrees (upside-down mode).  If plsdiori is\n"
19612                 "    not called the default value of rot is 0. \n"
19613                 "\n"
19614                 "    N.B. aspect ratio is unaffected by calls to plsdiori.  So you will\n"
19615                 "    probably want to change the aspect ratio to a value suitable for the\n"
19616                 "    plot orientation using a call to plsdidev or the command-line options\n"
19617                 "    -a or -freeaspect. For more documentation of those options see the\n"
19618                 "    PLplot documentation.  Such command-line options can be set internally\n"
19619                 "    using plsetopt or set directly using the command line and parsed using\n"
19620                 "    a call to  plparseopts. \n"
19621                 "\n"
19622                 "    Redacted form: plsdiori(rot)\n"
19623                 "\n"
19624                 "    This function is not used in any examples. \n"
19625                 "\n"
19626                 "\n"
19627                 "\n"
19628                 "SYNOPSIS:\n"
19629                 "\n"
19630                 "plsdiori(rot)\n"
19631                 "\n"
19632                 "ARGUMENTS:\n"
19633                 "\n"
19634                 "    rot (PLFLT, input) :    Plot orientation parameter. \n"
19635                 "\n"
19636                 ""},
19637          { (char *)"plsdiplt", _wrap_plsdiplt, METH_VARARGS, (char *)"\n"
19638                 "Set parameters that define current plot-space window \n"
19639                 "\n"
19640                 "DESCRIPTION:\n"
19641                 "\n"
19642                 "    Set relative minima and maxima that define the current plot-space\n"
19643                 "    window.  If plsdiplt is not called the default values of xmin, ymin,\n"
19644                 "    xmax, and ymax are 0., 0., 1., and 1. \n"
19645                 "\n"
19646                 "    Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
19647                 "\n"
19648                 "    This function is used in example 31. \n"
19649                 "\n"
19650                 "\n"
19651                 "\n"
19652                 "SYNOPSIS:\n"
19653                 "\n"
19654                 "plsdiplt(xmin, ymin, xmax, ymax)\n"
19655                 "\n"
19656                 "ARGUMENTS:\n"
19657                 "\n"
19658                 "    xmin (PLFLT, input) :    Relative minimum in x. \n"
19659                 "\n"
19660                 "    ymin (PLFLT, input) :    Relative minimum in y. \n"
19661                 "\n"
19662                 "    xmax (PLFLT, input) :    Relative maximum in x. \n"
19663                 "\n"
19664                 "    ymax (PLFLT, input) :    Relative maximum in y. \n"
19665                 "\n"
19666                 ""},
19667          { (char *)"plsdiplz", _wrap_plsdiplz, METH_VARARGS, (char *)"\n"
19668                 "Set parameters incrementally (zoom mode) that define current plot-space window \n"
19669                 "\n"
19670                 "DESCRIPTION:\n"
19671                 "\n"
19672                 "    Set relative minima and maxima incrementally (zoom mode) that define\n"
19673                 "    the current plot-space window.  This function has the same effect as\n"
19674                 "    plsdiplt if that function has not been previously called.  Otherwise,\n"
19675                 "    this function implements zoom mode using the transformation min_used =\n"
19676                 "    old_min + old_length*min  and max_used = old_min + old_length*max  for\n"
19677                 "    each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
19678                 "    repeated calls to plsdiplz will zoom in by 10 per cent for each call. \n"
19679                 "\n"
19680                 "    Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
19681                 "\n"
19682                 "    This function is used in example 31. \n"
19683                 "\n"
19684                 "\n"
19685                 "\n"
19686                 "SYNOPSIS:\n"
19687                 "\n"
19688                 "plsdiplz(xmin, ymin, xmax, ymax)\n"
19689                 "\n"
19690                 "ARGUMENTS:\n"
19691                 "\n"
19692                 "    xmin (PLFLT, input) :    Relative (incremental) minimum in x. \n"
19693                 "\n"
19694                 "    ymin (PLFLT, input) :    Relative (incremental) minimum in y. \n"
19695                 "\n"
19696                 "    xmax (PLFLT, input) :    Relative (incremental) maximum in x. \n"
19697                 "\n"
19698                 "    ymax (PLFLT, input) :    Relative (incremental) maximum in y. \n"
19699                 "\n"
19700                 ""},
19701          { (char *)"plseed", _wrap_plseed, METH_VARARGS, (char *)"\n"
19702                 "Set seed for internal random  number generator. \n"
19703                 "\n"
19704                 "DESCRIPTION:\n"
19705                 "\n"
19706                 "    Set the seed for the internal random number generator. See plrandd for\n"
19707                 "    further details. \n"
19708                 "\n"
19709                 "    Redacted form: plseed(seed)\n"
19710                 "\n"
19711                 "    This function is used in example 21. \n"
19712                 "\n"
19713                 "\n"
19714                 "\n"
19715                 "SYNOPSIS:\n"
19716                 "\n"
19717                 "plseed(seed)\n"
19718                 "\n"
19719                 "ARGUMENTS:\n"
19720                 "\n"
19721                 "    seed (unsigned int, input) :    Seed for random number generator. \n"
19722                 "\n"
19723                 ""},
19724          { (char *)"plsesc", _wrap_plsesc, METH_VARARGS, (char *)"\n"
19725                 "Set the escape character for text strings \n"
19726                 "\n"
19727                 "DESCRIPTION:\n"
19728                 "\n"
19729                 "    Set the escape character for text strings. From C (in contrast to\n"
19730                 "    Fortran 95, see plsescfortran95) you pass esc as a character. Only\n"
19731                 "    selected characters are allowed to prevent the user from shooting\n"
19732                 "    himself in the foot (For example, a \\ isn't allowed since it conflicts\n"
19733                 "    with C's use of backslash as a character escape).  Here are the\n"
19734                 "    allowed escape characters and their corresponding decimal ASCII\n"
19735                 "    values: !, ASCII 33 \n"
19736                 "           #, ASCII 35 \n"
19737                 "           $, ASCII 36 \n"
19738                 "           %, ASCII 37 \n"
19739                 "           &, ASCII 38 \n"
19740                 "           *, ASCII 42 \n"
19741                 "           @, ASCII 64 \n"
19742                 "           ^, ASCII 94 \n"
19743                 "           ~, ASCII 126 \n"
19744                 "\n"
19745                 "\n"
19746                 "    Redacted form:  General: plsesc(esc)\n"
19747                 "           Perl/PDL: Not available? \n"
19748                 "\n"
19749                 "\n"
19750                 "    This function is used in example 29. \n"
19751                 "\n"
19752                 "\n"
19753                 "\n"
19754                 "SYNOPSIS:\n"
19755                 "\n"
19756                 "plsesc(esc)\n"
19757                 "\n"
19758                 "ARGUMENTS:\n"
19759                 "\n"
19760                 "    esc (char, input) :    Escape character. \n"
19761                 "\n"
19762                 ""},
19763          { (char *)"plsetopt", _wrap_plsetopt, METH_VARARGS, (char *)"\n"
19764                 "Set any command-line option \n"
19765                 "\n"
19766                 "DESCRIPTION:\n"
19767                 "\n"
19768                 "    Set any command-line option internally from a program before it\n"
19769                 "    invokes plinit. opt is the name of the command-line option and optarg\n"
19770                 "    is the corresponding command-line option argument. \n"
19771                 "\n"
19772                 "    This function returns 0 on success. \n"
19773                 "\n"
19774                 "    Redacted form: plsetopt(opt, optarg)\n"
19775                 "\n"
19776                 "    This function is used in example 14. \n"
19777                 "\n"
19778                 "\n"
19779                 "\n"
19780                 "SYNOPSIS:\n"
19781                 "\n"
19782                 "int plsetopt(opt, optarg)\n"
19783                 "\n"
19784                 "ARGUMENTS:\n"
19785                 "\n"
19786                 "    opt (const char *, input) :    Pointer to string containing the\n"
19787                 "    command-line option. \n"
19788                 "\n"
19789                 "    optarg (const char *, input) :    Pointer to string containing the\n"
19790                 "    argument of the command-line option. \n"
19791                 "\n"
19792                 ""},
19793          { (char *)"plsfam", _wrap_plsfam, METH_VARARGS, (char *)"\n"
19794                 "Set family file parameters \n"
19795                 "\n"
19796                 "DESCRIPTION:\n"
19797                 "\n"
19798                 "    Sets variables dealing with output file familying. Does nothing if\n"
19799                 "    familying not supported by the driver.  This routine, if used, must be\n"
19800                 "    called before initializing PLplot. See the PLplot documentation for\n"
19801                 "    more information. \n"
19802                 "\n"
19803                 "    Redacted form: plsfam(fam, num, bmax)\n"
19804                 "\n"
19805                 "    This function is used in examples 14,31. \n"
19806                 "\n"
19807                 "\n"
19808                 "\n"
19809                 "SYNOPSIS:\n"
19810                 "\n"
19811                 "plsfam(fam, num, bmax)\n"
19812                 "\n"
19813                 "ARGUMENTS:\n"
19814                 "\n"
19815                 "    fam (PLINT, input) :    Family flag (Boolean).  If nonzero, familying\n"
19816                 "    is enabled. \n"
19817                 "\n"
19818                 "    num (PLINT, input) :    Current family file number. \n"
19819                 "\n"
19820                 "    bmax (PLINT, input) :    Maximum file size (in bytes) for a family\n"
19821                 "    file. \n"
19822                 "\n"
19823                 ""},
19824          { (char *)"plsfci", _wrap_plsfci, METH_VARARGS, (char *)"\n"
19825                 "Set FCI (font characterization integer) \n"
19826                 "\n"
19827                 "DESCRIPTION:\n"
19828                 "\n"
19829                 "    Sets font characteristics to be used at the start of the next string\n"
19830                 "    using the FCI approach. See the PLplot documentation for more\n"
19831                 "    information. \n"
19832                 "\n"
19833                 "    Redacted form:  General: plsfci(fci)\n"
19834                 "           Perl/PDL: Not available? \n"
19835                 "\n"
19836                 "\n"
19837                 "    This function is used in example 23. \n"
19838                 "\n"
19839                 "\n"
19840                 "\n"
19841                 "SYNOPSIS:\n"
19842                 "\n"
19843                 "plsfci(fci)\n"
19844                 "\n"
19845                 "ARGUMENTS:\n"
19846                 "\n"
19847                 "    fci (PLUNICODE, input) :    PLUNICODE (unsigned 32-bit integer) value\n"
19848                 "    of FCI. \n"
19849                 "\n"
19850                 ""},
19851          { (char *)"plsfnam", _wrap_plsfnam, METH_VARARGS, (char *)"\n"
19852                 "Set output file name \n"
19853                 "\n"
19854                 "DESCRIPTION:\n"
19855                 "\n"
19856                 "    Sets the current output file name, if applicable.  If the file name\n"
19857                 "    has not been specified and is required by the driver, the user will be\n"
19858                 "    prompted for it.  If using the X-windows output driver, this sets the\n"
19859                 "    display name.  This routine, if used, must be called before\n"
19860                 "    initializing PLplot. \n"
19861                 "\n"
19862                 "    Redacted form: plsfnam(fnam)\n"
19863                 "\n"
19864                 "    This function is used in examples 1,20. \n"
19865                 "\n"
19866                 "\n"
19867                 "\n"
19868                 "SYNOPSIS:\n"
19869                 "\n"
19870                 "plsfnam(fnam)\n"
19871                 "\n"
19872                 "ARGUMENTS:\n"
19873                 "\n"
19874                 "    fnam (const char *, input) :    Pointer to file name string. \n"
19875                 "\n"
19876                 ""},
19877          { (char *)"plsfont", _wrap_plsfont, METH_VARARGS, (char *)"\n"
19878                 "Set family, style and weight of the current font \n"
19879                 "\n"
19880                 "DESCRIPTION:\n"
19881                 "\n"
19882                 "    Sets the current font.  See the PLplot documentation for more\n"
19883                 "    information on font selection. \n"
19884                 "\n"
19885                 "    Redacted form: plsfont(family, style, weight)\n"
19886                 "\n"
19887                 "    This function is used in example 23. \n"
19888                 "\n"
19889                 "\n"
19890                 "\n"
19891                 "SYNOPSIS:\n"
19892                 "\n"
19893                 "plsfont(family, style, weight)\n"
19894                 "\n"
19895                 "ARGUMENTS:\n"
19896                 "\n"
19897                 "    family (PLINT, input) :    Font family to select for the current font.\n"
19898                 "    The available values are given by the PL_FCI_* constants in\n"
19899                 "    plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF, \n"
19900                 "    PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
19901                 "    signifies that the font family should not be altered.  \n"
19902                 "\n"
19903                 "    style (PLINT, input) :    Font style to select for the current font.\n"
19904                 "    The available values are given by the PL_FCI_* constants in\n"
19905                 "    plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
19906                 "    PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
19907                 "    should not be altered.    \n"
19908                 "\n"
19909                 "    weight (PLINT, input) :    Font weight to select for the current font.\n"
19910                 "    The available values are given by the PL_FCI_* constants in\n"
19911                 "    plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
19912                 "    negative value signifies that the font weight should not be\n"
19913                 "    altered.  \n"
19914                 "\n"
19915                 ""},
19916          { (char *)"plshades", _wrap_plshades, METH_VARARGS, (char *)"\n"
19917                 "Shade regions on the basis of value \n"
19918                 "\n"
19919                 "DESCRIPTION:\n"
19920                 "\n"
19921                 "    Shade regions on the basis of value.  This is the high-level routine\n"
19922                 "    for making continuous color shaded plots with cmap1 while plshade (or\n"
19923                 "    plshade1) are used for individual shaded regions using either cmap0 or\n"
19924                 "    cmap1. examples/c/x16c.c shows a number of examples for using this\n"
19925                 "    function. See the following discussion of the arguments and the PLplot\n"
19926                 "    documentation for more information.    \n"
19927                 "\n"
19928                 "    Redacted form:  General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
19929                 "    clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
19930                 "    pltr_data)\n"
19931                 "           Perl/PDL: plshades(a, xmin, xmax, ymin, ymax, clevel,\n"
19932                 "    fill_width, cont_color, cont_width, fill, rectangular, defined, pltr,\n"
19933                 "    pltr_data)\n"
19934                 "\n"
19935                 "\n"
19936                 "    This function is used in examples 16,21. \n"
19937                 "\n"
19938                 "\n"
19939                 "\n"
19940                 "SYNOPSIS:\n"
19941                 "\n"
19942                 "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
19943                 "\n"
19944                 "ARGUMENTS:\n"
19945                 "\n"
19946                 "    a (const PLFLT * const *, input) :      Contains ** pointer to array to\n"
19947                 "    be plotted. The array must have been declared as PLFLT a[nx][ny]. \n"
19948                 "\n"
19949                 "    nx (PLINT, input) :    First dimension of array \"a\". \n"
19950                 "\n"
19951                 "    ny (PLINT, input) :    Second dimension of array \"a\". \n"
19952                 "\n"
19953                 "    defined (PLINT (*) (PLFLT, PLFLT), input) :    User function\n"
19954                 "    specifying regions excluded from the shading plot.  This function\n"
19955                 "    accepts x and y coordinates as input arguments and must return 0\n"
19956                 "    if the point is in the excluded region or 1 otherwise. This\n"
19957                 "    argument can be NULL if all the values are valid. \n"
19958                 "\n"
19959                 "    xmin (PLFLT, input) :    Defines the \"grid\" coordinates.  The data\n"
19960                 "    a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19961                 "    at (xmax,ymin) and so on. \n"
19962                 "\n"
19963                 "    xmax (PLFLT, input) :    Defines the \"grid\" coordinates.  The data\n"
19964                 "    a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19965                 "    at (xmax,ymin) and so on. \n"
19966                 "\n"
19967                 "    ymin (PLFLT, input) :    Defines the \"grid\" coordinates.  The data\n"
19968                 "    a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19969                 "    at (xmax,ymin) and so on. \n"
19970                 "\n"
19971                 "    ymax (PLFLT, input) :    Defines the \"grid\" coordinates.  The data\n"
19972                 "    a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n"
19973                 "    at (xmax,ymin) and so on. \n"
19974                 "\n"
19975                 "    clevel (const PLFLT *, input) :    Pointer to array containing the\n"
19976                 "    data levels corresponding to the edges of each shaded region that\n"
19977                 "    will be plotted by this function.  To work properly the levels\n"
19978                 "    should be monotonic. \n"
19979                 "\n"
19980                 "    nlevel (PLINT, input) :    Number of shades plus 1 (i.e., the number\n"
19981                 "    of shade edge values in clevel). \n"
19982                 "\n"
19983                 "    fill_width (PLFLT, input) :    Defines line width used by the fill\n"
19984                 "    pattern. \n"
19985                 "\n"
19986                 "    cont_color (PLINT, input) :    Defines pen color used for contours\n"
19987                 "    defining edges of shaded regions.  The pen color is only temporary\n"
19988                 "    set for the contour drawing.  Set this value to zero or less if no\n"
19989                 "    shade edge contours are wanted. \n"
19990                 "\n"
19991                 "    cont_width (PLFLT, input) :    Defines line width used for contours\n"
19992                 "    defining edges of shaded regions.  This value may not be honored\n"
19993                 "    by all drivers. The pen width is only temporary set for the\n"
19994                 "    contour drawing.  Set this value to zero or less if no shade edge\n"
19995                 "    contours are wanted. \n"
19996                 "\n"
19997                 "    fill (void (*) (PLINT, const PLFLT *, const PLFLT *), input) :   \n"
19998                 "    Routine used to fill the region.  Use plfill.  Future version of\n"
19999                 "    PLplot may have other fill routines. \n"
20000                 "\n"
20001                 "    rectangular (PLBOOL, input) :    Set rectangular to true if rectangles\n"
20002                 "    map to rectangles after coordinate transformation with pltrl. \n"
20003                 "    Otherwise, set rectangular to false. If rectangular is set to\n"
20004                 "    true, plshade tries to save time by filling large rectangles. \n"
20005                 "    This optimization fails if the coordinate transformation distorts\n"
20006                 "    the shape of rectangles. For example a plot in polar coordinates\n"
20007                 "    has to have  rectangular set to false. \n"
20008                 "\n"
20009                 "    pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
20010                 "      Pointer to function that defines transformation between indices\n"
20011                 "    in array z and the world coordinates (C only).    Transformation\n"
20012                 "    functions are provided in the PLplot library: pltr0 for identity\n"
20013                 "    mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
20014                 "    defined by one- and two-dimensional arrays.  In addition,\n"
20015                 "    user-supplied routines for the transformation can be used as well.\n"
20016                 "     Examples of all of these approaches are given in the PLplot\n"
20017                 "    documentation. The transformation function should have the form\n"
20018                 "    given by any of pltr0, pltr1, or pltr2. \n"
20019                 "\n"
20020                 "    pltr_data (PLPointer, input) :    Extra parameter to help pass\n"
20021                 "    information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20022                 "    externally supplied. \n"
20023                 "\n"
20024                 ""},
20025          { (char *)"plshade", _wrap_plshade, METH_VARARGS, (char *)"\n"
20026                 "Shade individual region on the basis of value \n"
20027                 "\n"
20028                 "ESCRIPTION:\n"
20029                 "\n"
20030                 "   Shade individual region on the basis of value.  Use plshades if you\n"
20031                 "   want to shade a number of regions using continuous colors. plshade is\n"
20032                 "   identical to plshade1 except for the type of the first parameter. See\n"
20033                 "   plshade1 for further discussion. \n"
20034                 "\n"
20035                 "   Redacted form:  General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
20036                 "   shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
20037                 "   min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20038                 "    Perl/PDL: Not available? \n"
20039                 "\n"
20040                 "\n"
20041                 "   This function is used in example 15. \n"
20042                 "\n"
20043                 "\n"
20044                 "\n"
20045                 "YNOPSIS:\n"
20046                 "\n"
20047                 "lshade(a, nx, ny, defined, xmin, xmax, ymin, ymax, shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color, min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20048                 "\n"
20049                 "RGUMENTS:\n"
20050                 "\n"
20051                 "   a (const PLFLT * const *, input) :      \n"
20052                 "\n"
20053                 "   nx (PLINT, input) :    \n"
20054                 "\n"
20055                 "   ny (PLINT, input) :    \n"
20056                 "\n"
20057                 "   defined (PLINT (*) (PLFLT, PLFLT), input) :    \n"
20058                 "\n"
20059                 "   xmin (PLFLT, input) :    \n"
20060                 "\n"
20061                 "   xmax (PLFLT, input) :    \n"
20062                 "\n"
20063                 "   ymin (PLFLT, input) :    \n"
20064                 "\n"
20065                 "   ymax (PLFLT, input) :    \n"
20066                 "\n"
20067                 "   shade_min (PLFLT, input) :      \n"
20068                 "\n"
20069                 "   shade_max (PLFLT, input) :      \n"
20070                 "\n"
20071                 "   sh_cmap (PLINT, input) :    \n"
20072                 "\n"
20073                 "   sh_color (PLFLT, input) :     \n"
20074                 "\n"
20075                 "   sh_width (PLFLT, input) :     \n"
20076                 "\n"
20077                 "   min_color (PLINT, input) :      \n"
20078                 "\n"
20079                 "   min_width (PLFLT, input) :      \n"
20080                 "\n"
20081                 "   max_color (PLINT, input) :      \n"
20082                 "\n"
20083                 "   max_width (PLFLT, input) :      \n"
20084                 "\n"
20085                 "   fill (void (*) (PLINT, const PLFLT *, const PLFLT *), input) :    \n"
20086                 "\n"
20087                 "   rectangular (PLBOOL, input) :    \n"
20088                 "\n"
20089                 "   pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) :  \n"
20090                 "\n"
20091                 "   pltr_data (PLPointer, input) :    \n"
20092                 "\n"
20093                 ""},
20094          { (char *)"plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, (char *)"\n"
20095                 "Assign a function to use for generating custom axis labels \n"
20096                 "\n"
20097                 "DESCRIPTION:\n"
20098                 "\n"
20099                 "    This function allows a user to provide their own function to provide\n"
20100                 "    axis label text.  The user function is given the numeric value for a\n"
20101                 "    point on an axis and returns a string label to correspond with that\n"
20102                 "    value.  Custom axis labels can be enabled by passing appropriate\n"
20103                 "    arguments to plenv, plbox, plbox3 and similar functions. \n"
20104                 "\n"
20105                 "    This function is used in example 19. \n"
20106                 "\n"
20107                 "\n"
20108                 "\n"
20109                 "SYNOPSIS:\n"
20110                 "\n"
20111                 "plslabelfunc(label_func, label_data)\n"
20112                 "\n"
20113                 "ARGUMENTS:\n"
20114                 "\n"
20115                 "    label_func (void (*) (PLINT, PLFLT, char *, PLINT, PLPointer), input)\n"
20116                 "    :    This is the custom label function.  In order to reset to the\n"
20117                 "    default labelling, set this to NULL. The labelling function\n"
20118                 "    parameters are, in order: axis:    This indicates which axis a\n"
20119                 "    label is being requested for. The value will be one of PL_X_AXIS,\n"
20120                 "    PL_Y_AXIS or PL_Z_AXIS. \n"
20121                 "\n"
20122                 "    value:    This is the value along the axis which is being labelled. \n"
20123                 "\n"
20124                 "    label_text:    The string representation of the label value. \n"
20125                 "\n"
20126                 "    length:    The maximum length in characters allowed for label_text. \n"
20127                 "\n"
20128                 "\n"
20129                 "    label_data (PLPointer, input) :    This parameter may be used to pass\n"
20130                 "    data to the label_func function. \n"
20131                 "\n"
20132                 ""},
20133          { (char *)"plsmaj", _wrap_plsmaj, METH_VARARGS, (char *)"\n"
20134                 "Set length of major ticks \n"
20135                 "\n"
20136                 "DESCRIPTION:\n"
20137                 "\n"
20138                 "    This sets up the length of the major ticks.  The actual length is the\n"
20139                 "    product of the default length and a scaling factor as for character\n"
20140                 "    height. \n"
20141                 "\n"
20142                 "    Redacted form: plsmaj(def, scale)\n"
20143                 "\n"
20144                 "    This function is used in example 29. \n"
20145                 "\n"
20146                 "\n"
20147                 "\n"
20148                 "SYNOPSIS:\n"
20149                 "\n"
20150                 "plsmaj(def, scale)\n"
20151                 "\n"
20152                 "ARGUMENTS:\n"
20153                 "\n"
20154                 "    def (PLFLT, input) :    The default length of a major tick in\n"
20155                 "    millimeters, should be set to zero if the default length is to\n"
20156                 "    remain unchanged. \n"
20157                 "\n"
20158                 "    scale (PLFLT, input) :    Scale factor to be applied to default to get\n"
20159                 "    actual tick length. \n"
20160                 "\n"
20161                 ""},
20162          { (char *)"plsmem", _wrap_plsmem, METH_VARARGS, (char *)"\n"
20163                 "Set the memory area to be plotted (RGB) \n"
20164                 "\n"
20165                 "DESCRIPTION:\n"
20166                 "\n"
20167                 "    Set the memory area to be plotted (with the mem or memcairo driver) as\n"
20168                 "    the dev member of the stream structure.  Also set the number of pixels\n"
20169                 "    in the memory passed in \n"
20170                 "    plotmem, which is a block of memory \n"
20171                 "    maxy by \n"
20172                 "    maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB) \n"
20173                 "\n"
20174                 "    This memory will have to be freed by the user! \n"
20175                 "\n"
20176                 "    Redacted form: plsmem(maxx, maxy, plotmem)\n"
20177                 "\n"
20178                 "    This function is not used in any examples. \n"
20179                 "\n"
20180                 "\n"
20181                 "\n"
20182                 "SYNOPSIS:\n"
20183                 "\n"
20184                 "plsmem(maxx, maxy, plotmem)\n"
20185                 "\n"
20186                 "ARGUMENTS:\n"
20187                 "\n"
20188                 "    maxx (PLINT, input) :    Size of memory area in the X coordinate. \n"
20189                 "\n"
20190                 "    maxy (PLINT, input) :    Size of memory area in the Y coordinate. \n"
20191                 "\n"
20192                 "    plotmem (void *, input) :     Pointer to the beginning of the\n"
20193                 "    user-supplied memory area. \n"
20194                 "\n"
20195                 ""},
20196          { (char *)"plsmema", _wrap_plsmema, METH_VARARGS, (char *)"\n"
20197                 "Set the memory area to be plotted (RGBA) \n"
20198                 "\n"
20199                 "DESCRIPTION:\n"
20200                 "\n"
20201                 "    Set the memory area to be plotted (with the memcairo driver) as the\n"
20202                 "    dev member of the stream structure. Also set the number of pixels in\n"
20203                 "    the memory passed in \n"
20204                 "    plotmem, which is a block of memory \n"
20205                 "    maxy by \n"
20206                 "    maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA) \n"
20207                 "\n"
20208                 "    This memory will have to be freed by the user! \n"
20209                 "\n"
20210                 "    Redacted form: plsmema(maxx, maxy, plotmem)\n"
20211                 "\n"
20212                 "    This function is not used in any examples. \n"
20213                 "\n"
20214                 "\n"
20215                 "\n"
20216                 "SYNOPSIS:\n"
20217                 "\n"
20218                 "plsmema(maxx, maxy, plotmem)\n"
20219                 "\n"
20220                 "ARGUMENTS:\n"
20221                 "\n"
20222                 "    maxx (PLINT, input) :    Size of memory area in the X coordinate. \n"
20223                 "\n"
20224                 "    maxy (PLINT, input) :    Size of memory area in the Y coordinate. \n"
20225                 "\n"
20226                 "    plotmem (void *, input) :     Pointer to the beginning of the\n"
20227                 "    user-supplied memory area. \n"
20228                 "\n"
20229                 ""},
20230          { (char *)"plsmin", _wrap_plsmin, METH_VARARGS, (char *)"\n"
20231                 "Set length of minor ticks \n"
20232                 "\n"
20233                 "DESCRIPTION:\n"
20234                 "\n"
20235                 "    This sets up the length of the minor ticks and the length of the\n"
20236                 "    terminals on error bars.  The actual length is the product of the\n"
20237                 "    default length and a scaling factor as for character height. \n"
20238                 "\n"
20239                 "    Redacted form: plsmin(def, scale)\n"
20240                 "\n"
20241                 "    This function is used in example 29. \n"
20242                 "\n"
20243                 "\n"
20244                 "\n"
20245                 "SYNOPSIS:\n"
20246                 "\n"
20247                 "plsmin(def, scale)\n"
20248                 "\n"
20249                 "ARGUMENTS:\n"
20250                 "\n"
20251                 "    def (PLFLT, input) :    The default length of a minor tick in\n"
20252                 "    millimeters, should be set to zero if the default length is to\n"
20253                 "    remain unchanged. \n"
20254                 "\n"
20255                 "    scale (PLFLT, input) :    Scale factor to be applied to default to get\n"
20256                 "    actual tick length. \n"
20257                 "\n"
20258                 ""},
20259          { (char *)"plsori", _wrap_plsori, METH_VARARGS, (char *)"\n"
20260                 "Set orientation \n"
20261                 "\n"
20262                 "DESCRIPTION:\n"
20263                 "\n"
20264                 "    Set integer plot orientation parameter.  This function is identical to\n"
20265                 "    plsdiori except for the type of the argument, and should be used in\n"
20266                 "    the same way.  See the PLplot documentation for details. \n"
20267                 "\n"
20268                 "    Redacted form: plsori(ori)\n"
20269                 "\n"
20270                 "    This function is used in example 3. \n"
20271                 "\n"
20272                 "\n"
20273                 "\n"
20274                 "SYNOPSIS:\n"
20275                 "\n"
20276                 "plsori(ori)\n"
20277                 "\n"
20278                 "ARGUMENTS:\n"
20279                 "\n"
20280                 "    ori (PLINT, input) :    Orientation value (0 for landscape, 1 for\n"
20281                 "    portrait, etc.) The value is multiplied by 90 degrees to get the\n"
20282                 "    angle. \n"
20283                 "\n"
20284                 ""},
20285          { (char *)"plspage", _wrap_plspage, METH_VARARGS, (char *)"\n"
20286                 "Set page parameters \n"
20287                 "\n"
20288                 "DESCRIPTION:\n"
20289                 "\n"
20290                 "    Sets the page configuration (optional).  If an individual parameter is\n"
20291                 "    zero then that parameter value is not updated.  Not all parameters are\n"
20292                 "    recognized by all drivers and the interpretation is device-dependent.\n"
20293                 "    The X-window driver uses the length and offset parameters to determine\n"
20294                 "    the window size and location.  The length and offset values are\n"
20295                 "    expressed in units that are specific to the current driver. For\n"
20296                 "    instance: screen drivers will usually interpret them as number of\n"
20297                 "    pixels, whereas printer drivers will usually use mm. This routine, if\n"
20298                 "    used, must be called before initializing PLplot. \n"
20299                 "\n"
20300                 "    Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
20301                 "\n"
20302                 "    This function is used in examples 14 and 31. \n"
20303                 "\n"
20304                 "\n"
20305                 "\n"
20306                 "SYNOPSIS:\n"
20307                 "\n"
20308                 "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
20309                 "\n"
20310                 "ARGUMENTS:\n"
20311                 "\n"
20312                 "    xp (PLFLT, input) :    Number of pixels/inch (DPI), x. \n"
20313                 "\n"
20314                 "    yp (PLFLT, input) :    Number of pixels/inch (DPI), y. \n"
20315                 "\n"
20316                 "    xleng (PLINT , input) :    Page length, x. \n"
20317                 "\n"
20318                 "    yleng (PLINT, input) :    Page length, y. \n"
20319                 "\n"
20320                 "    xoff (PLINT, input) :    Page offset, x. \n"
20321                 "\n"
20322                 "    yoff (PLINT, input) :    Page offset, y. \n"
20323                 "\n"
20324                 ""},
20325          { (char *)"plspal0", _wrap_plspal0, METH_VARARGS, (char *)"\n"
20326                 "Set the colors for color table 0 from a cmap0 file \n"
20327                 "\n"
20328                 "DESCRIPTION:\n"
20329                 "\n"
20330                 "    Set the colors for color table 0 from a cmap0 file \n"
20331                 "\n"
20332                 "    Redacted form: plspal0(filename)\n"
20333                 "\n"
20334                 "    This function is in example 16. \n"
20335                 "\n"
20336                 "\n"
20337                 "\n"
20338                 "SYNOPSIS:\n"
20339                 "\n"
20340                 "plspal0(filename)\n"
20341                 "\n"
20342                 "ARGUMENTS:\n"
20343                 "\n"
20344                 "    filename (const char *, input) :    The name of the cmap0 file, or a\n"
20345                 "    empty to string to specify the default cmap0 file. \n"
20346                 "\n"
20347                 ""},
20348          { (char *)"plspal1", _wrap_plspal1, METH_VARARGS, (char *)"\n"
20349                 "Set the palette for cmap1 using the specified cmap1*.pal format file \n"
20350                 "\n"
20351                 "DESCRIPTION:\n"
20352                 "\n"
20353                 "    Set the palette for cmap1 using the specified cmap1*.pal format file. \n"
20354                 "\n"
20355                 "    Redacted form: plspal1(filename, interpolate)\n"
20356                 "\n"
20357                 "    This function is used in example 16. \n"
20358                 "\n"
20359                 "\n"
20360                 "\n"
20361                 "SYNOPSIS:\n"
20362                 "\n"
20363                 "plspal1(filename, interpolate)\n"
20364                 "\n"
20365                 "ARGUMENTS:\n"
20366                 "\n"
20367                 "    filename (const char *, input) :    The name of the cmap1*.pal file,\n"
20368                 "    or an empty string to specify the default cmap1.pal file. \n"
20369                 "\n"
20370                 "    interpolate (PLBOOL, input) :    If this parameter is true, the\n"
20371                 "    columns containing the intensity index, r, g, b, alpha and\n"
20372                 "    alt_hue_path in the cmap1*.pal file are used to set the cmap1\n"
20373                 "    palette with a call to plscmap1la. (The cmap1*.pal header contains\n"
20374                 "    a flag which controls whether the r, g, b data sent to plscmap1la\n"
20375                 "    are interpreted as HLS or RGB.) If this parameter is false, the\n"
20376                 "    intensity index and alt_hue_path columns are ignored and the r, g,\n"
20377                 "    b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n"
20378                 "    are used instead to set the cmap1 palette directly with a call to\n"
20379                 "    plscmap1a. \n"
20380                 "\n"
20381                 ""},
20382          { (char *)"plspause", _wrap_plspause, METH_VARARGS, (char *)"\n"
20383                 "Set the pause (on end-of-page) status \n"
20384                 "\n"
20385                 "DESCRIPTION:\n"
20386                 "\n"
20387                 "    Set the pause (on end-of-page) status. \n"
20388                 "\n"
20389                 "    Redacted form: plspause(pause)\n"
20390                 "\n"
20391                 "    This function is in examples 14,20. \n"
20392                 "\n"
20393                 "\n"
20394                 "\n"
20395                 "SYNOPSIS:\n"
20396                 "\n"
20397                 "plspause(pause)\n"
20398                 "\n"
20399                 "ARGUMENTS:\n"
20400                 "\n"
20401                 "    pause (PLBOOL, input) :    If pause is true there will be a pause on\n"
20402                 "    end-of-page for those drivers which support this.  Otherwise there\n"
20403                 "    is no pause. \n"
20404                 "\n"
20405                 ""},
20406          { (char *)"plsstrm", _wrap_plsstrm, METH_VARARGS, (char *)"\n"
20407                 "Set current output stream \n"
20408                 "\n"
20409                 "DESCRIPTION:\n"
20410                 "\n"
20411                 "    Sets the number of the current output stream.  The stream number\n"
20412                 "    defaults to 0 unless changed by this routine.  The first use of this\n"
20413                 "    routine must be followed by a call initializing PLplot (e.g. plstar). \n"
20414                 "\n"
20415                 "    Redacted form: plsstrm(strm)\n"
20416                 "\n"
20417                 "    This function is examples 1,14,20. \n"
20418                 "\n"
20419                 "\n"
20420                 "\n"
20421                 "SYNOPSIS:\n"
20422                 "\n"
20423                 "plsstrm(strm)\n"
20424                 "\n"
20425                 "ARGUMENTS:\n"
20426                 "\n"
20427                 "    strm (PLINT, input) :    The current stream number. \n"
20428                 "\n"
20429                 ""},
20430          { (char *)"plssub", _wrap_plssub, METH_VARARGS, (char *)"\n"
20431                 "Set the number of subpages in x and y \n"
20432                 "\n"
20433                 "DESCRIPTION:\n"
20434                 "\n"
20435                 "    Set the number of subpages in x and y. \n"
20436                 "\n"
20437                 "    Redacted form: plssub(nx, ny)\n"
20438                 "\n"
20439                 "    This function is examples 1,2,14,21,25,27. \n"
20440                 "\n"
20441                 "\n"
20442                 "\n"
20443                 "SYNOPSIS:\n"
20444                 "\n"
20445                 "plssub(nx, ny)\n"
20446                 "\n"
20447                 "ARGUMENTS:\n"
20448                 "\n"
20449                 "    nx (PLINT, input) :    Number of windows in x direction (i.e., number\n"
20450                 "    of window columns). \n"
20451                 "\n"
20452                 "    ny (PLINT, input) :    Number of windows in y direction (i.e., number\n"
20453                 "    of window rows). \n"
20454                 "\n"
20455                 ""},
20456          { (char *)"plssym", _wrap_plssym, METH_VARARGS, (char *)"\n"
20457                 "Set symbol size \n"
20458                 "\n"
20459                 "DESCRIPTION:\n"
20460                 "\n"
20461                 "    This sets up the size of all subsequent symbols drawn by plpoin and\n"
20462                 "    plsym.  The actual height of a symbol is the product of the default\n"
20463                 "    symbol size and a scaling factor as for the character height. \n"
20464                 "\n"
20465                 "    Redacted form: plssym(def, scale)\n"
20466                 "\n"
20467                 "    This function is used in example 29. \n"
20468                 "\n"
20469                 "\n"
20470                 "\n"
20471                 "SYNOPSIS:\n"
20472                 "\n"
20473                 "plssym(def, scale)\n"
20474                 "\n"
20475                 "ARGUMENTS:\n"
20476                 "\n"
20477                 "    def (PLFLT, input) :    The default height of a symbol in millimeters,\n"
20478                 "    should be set to zero if the default height is to remain\n"
20479                 "    unchanged. \n"
20480                 "\n"
20481                 "    scale (PLFLT, input) :    Scale factor to be applied to default to get\n"
20482                 "    actual symbol height. \n"
20483                 "\n"
20484                 ""},
20485          { (char *)"plstar", _wrap_plstar, METH_VARARGS, (char *)"\n"
20486                 "Initialization \n"
20487                 "\n"
20488                 "DESCRIPTION:\n"
20489                 "\n"
20490                 "    Initializing the plotting package. The program prompts for the device\n"
20491                 "    keyword or number of the desired output device.  Hitting a RETURN in\n"
20492                 "    response to the prompt is the same as selecting the first device.  If\n"
20493                 "    only one device is enabled when PLplot is installed, plstar will issue\n"
20494                 "    no prompt. The output device is divided into nx by ny subpages, each\n"
20495                 "    of which may be used independently.  The subroutine pladv is used to\n"
20496                 "    advance from one subpage to the next. \n"
20497                 "\n"
20498                 "    Redacted form: plstar(nx, ny)\n"
20499                 "\n"
20500                 "    This function is used in example 1. \n"
20501                 "\n"
20502                 "\n"
20503                 "\n"
20504                 "SYNOPSIS:\n"
20505                 "\n"
20506                 "plstar(nx, ny)\n"
20507                 "\n"
20508                 "ARGUMENTS:\n"
20509                 "\n"
20510                 "    nx (PLINT, input) :    Number of subpages to divide output page in the\n"
20511                 "    horizontal direction. \n"
20512                 "\n"
20513                 "    ny (PLINT, input) :    Number of subpages to divide output page in the\n"
20514                 "    vertical direction. \n"
20515                 "\n"
20516                 ""},
20517          { (char *)"plstart", _wrap_plstart, METH_VARARGS, (char *)"\n"
20518                 "Initialization \n"
20519                 "\n"
20520                 "DESCRIPTION:\n"
20521                 "\n"
20522                 "    Alternative to plstar for initializing the plotting package.  The\n"
20523                 "    device name keyword for the desired output device must be supplied as\n"
20524                 "    an argument.  These keywords are the same as those printed out by\n"
20525                 "    plstar.  If the requested device is not available, or if the input\n"
20526                 "    string is empty or begins with ``?'', the prompted start up of plstar\n"
20527                 "    is used.  This routine also divides the output device page into nx by\n"
20528                 "    ny subpages, each of which may be used independently.  The subroutine\n"
20529                 "    pladv is used to advance from one subpage to the next. \n"
20530                 "\n"
20531                 "    Redacted form:  General: plstart(devname, nx, ny)\n"
20532                 "           Perl/PDL: plstart(nx, ny, devname)\n"
20533                 "\n"
20534                 "\n"
20535                 "    This function is not used in any examples. \n"
20536                 "\n"
20537                 "\n"
20538                 "\n"
20539                 "SYNOPSIS:\n"
20540                 "\n"
20541                 "plstart(devname, nx, ny)\n"
20542                 "\n"
20543                 "ARGUMENTS:\n"
20544                 "\n"
20545                 "    devname (const char *, input) :    Device name keyword of the required\n"
20546                 "    output device.    If NULL or if the first character is a ``?'', the\n"
20547                 "    normal (prompted) start up is used. \n"
20548                 "\n"
20549                 "    nx (PLINT, input) :    Number of subpages to divide output page in the\n"
20550                 "    horizontal direction. \n"
20551                 "\n"
20552                 "    ny (PLINT, input) :    Number of subpages to divide output page in the\n"
20553                 "    vertical direction. \n"
20554                 "\n"
20555                 ""},
20556          { (char *)"plstransform", _wrap_plstransform, METH_VARARGS, (char *)"\n"
20557                 "Set a global coordinate transform function \n"
20558                 "\n"
20559                 "DESCRIPTION:\n"
20560                 "\n"
20561                 "    This function can be used to define a coordinate transformation which\n"
20562                 "    affects all elements drawn within the current plot window. The\n"
20563                 "    coordinate_transform function is similar to that provided for the\n"
20564                 "    plmap and plmeridians functions.  The coordinate_transform_data\n"
20565                 "    parameter may be used to pass extra data to coordinate_transform. \n"
20566                 "\n"
20567                 "    Redacted form:  General: plstransform(coordinate_transform,\n"
20568                 "    coordinate_transform_data)\n"
20569                 "\n"
20570                 "\n"
20571                 "    This function is used in examples 19 and 22. \n"
20572                 "\n"
20573                 "\n"
20574                 "\n"
20575                 "SYNOPSIS:\n"
20576                 "\n"
20577                 "plstransform(coordinate_transform, coordinate_transform_data)\n"
20578                 "\n"
20579                 "ARGUMENTS:\n"
20580                 "\n"
20581                 "    coordinate_transform (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *,\n"
20582                 "    PLPointer) , input) :     Pointer to a function that defines a\n"
20583                 "    transformation from the input (x, y) coordinate to a new plot\n"
20584                 "    world coordinate. A NULL pointer  means that no transform is\n"
20585                 "    applied. \n"
20586                 "\n"
20587                 "    coordinate_transform_data (PLPointer, input) :    Optional extra data\n"
20588                 "    for \n"
20589                 "    coordinate_transform. \n"
20590                 "\n"
20591                 ""},
20592          { (char *)"plstring", _wrap_plstring, METH_VARARGS, (char *)"\n"
20593                 "Plot a glyph at the specified points \n"
20594                 "\n"
20595                 "DESCRIPTION:\n"
20596                 "\n"
20597                 "    Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
20598                 "    because many[!] more glyphs are accessible with plstring.) The glyph\n"
20599                 "    is specified with a PLplot user string.  Note that the user string is\n"
20600                 "    not actually limited to one glyph so it is possible (but not normally\n"
20601                 "    useful) to plot more than one glyph at the specified points with this\n"
20602                 "    function.  As with plmtex and plptex, the user string can contain FCI\n"
20603                 "    escapes to determine the font, UTF-8 code to determine the glyph or\n"
20604                 "    else PLplot escapes for Hershey or unicode text to determine the\n"
20605                 "    glyph. \n"
20606                 "\n"
20607                 "    Redacted form: plstring(x, y, string)\n"
20608                 "\n"
20609                 "    This function is used in examples 4, 21 and 26. \n"
20610                 "\n"
20611                 "\n"
20612                 "\n"
20613                 "SYNOPSIS:\n"
20614                 "\n"
20615                 "plstring(n, x, y, string)\n"
20616                 "\n"
20617                 "ARGUMENTS:\n"
20618                 "\n"
20619                 "    n (PLINT, input) :      Number of points in the x and y arrays. \n"
20620                 "\n"
20621                 "    x (const PLFLT *, input) :      Pointer to an array with X coordinates\n"
20622                 "    of points. \n"
20623                 "\n"
20624                 "    y (const PLFLT *, input) :      Pointer to an array with Y coordinates\n"
20625                 "    of points. \n"
20626                 "\n"
20627                 "    string (const char *, input) :    PLplot user string corresponding to\n"
20628                 "    the glyph to be plotted at each of the n points. \n"
20629                 "\n"
20630                 ""},
20631          { (char *)"plstring3", _wrap_plstring3, METH_VARARGS, (char *)"\n"
20632                 "Plot a glyph at the specified 3D points \n"
20633                 "\n"
20634                 "DESCRIPTION:\n"
20635                 "\n"
20636                 "    Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
20637                 "    many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
20638                 "    this function similar to what is done for plline3. The glyph is\n"
20639                 "    specified with a PLplot user string.  Note that the user string is not\n"
20640                 "    actually limited to one glyph so it is possible (but not normally\n"
20641                 "    useful) to plot more than one glyph at the specified points with this\n"
20642                 "    function.  As with plmtex and plptex, the user string can contain FCI\n"
20643                 "    escapes to determine the font, UTF-8 code to determine the glyph or\n"
20644                 "    else PLplot escapes for Hershey or unicode text to determine the\n"
20645                 "    glyph. \n"
20646                 "\n"
20647                 "    Redacted form: plstring3(x, y, z, string)\n"
20648                 "\n"
20649                 "    This function is used in example 18. \n"
20650                 "\n"
20651                 "\n"
20652                 "\n"
20653                 "SYNOPSIS:\n"
20654                 "\n"
20655                 "plstring3(n, x, y, z, string)\n"
20656                 "\n"
20657                 "ARGUMENTS:\n"
20658                 "\n"
20659                 "    n (PLINT, input) :      Number of points in the x, y, and z arrays. \n"
20660                 "\n"
20661                 "    x (const PLFLT *, input) :      Pointer to an array with X coordinates\n"
20662                 "    of points. \n"
20663                 "\n"
20664                 "    y (const PLFLT *, input) :      Pointer to an array with Y coordinates\n"
20665                 "    of points. \n"
20666                 "\n"
20667                 "    z (const PLFLT *, input) :      Pointer to an array with Z coordinates\n"
20668                 "    of points. \n"
20669                 "\n"
20670                 "    string (const char *, input) :    PLplot user string corresponding to\n"
20671                 "    the glyph to be plotted at each of the n points. \n"
20672                 "\n"
20673                 ""},
20674          { (char *)"plstripa", _wrap_plstripa, METH_VARARGS, (char *)"\n"
20675                 "Add a point to a strip chart \n"
20676                 "\n"
20677                 "DESCRIPTION:\n"
20678                 "\n"
20679                 "    Add a point to a given pen of a given strip chart. There is no need\n"
20680                 "    for all pens to have the same number of points or to be equally\n"
20681                 "    sampled in the x coordinate. Allocates memory and rescales as\n"
20682                 "    necessary. \n"
20683                 "\n"
20684                 "    Redacted form: plstripa(id, pen, x, y)\n"
20685                 "\n"
20686                 "    This function is used in example 17. \n"
20687                 "\n"
20688                 "\n"
20689                 "\n"
20690                 "SYNOPSIS:\n"
20691                 "\n"
20692                 "plstripa(id, pen, x, y)\n"
20693                 "\n"
20694                 "ARGUMENTS:\n"
20695                 "\n"
20696                 "    id (PLINT, input) :    Identification number of the strip chart (set\n"
20697                 "    up in plstripc). \n"
20698                 "\n"
20699                 "    pen (PLINT, input) :    Pen number (ranges from 0 to 3). \n"
20700                 "\n"
20701                 "    x (PLFLT, input) :      X coordinate of point to plot. \n"
20702                 "\n"
20703                 "    y (PLFLT, input) :      Y coordinate of point to plot. \n"
20704                 "\n"
20705                 ""},
20706          { (char *)"plstripc", _wrap_plstripc, METH_VARARGS, (char *)"\n"
20707                 "Create a 4-pen strip chart \n"
20708                 "\n"
20709                 "DESCRIPTION:\n"
20710                 "\n"
20711                 "    Create a 4-pen strip chart, to be used afterwards by plstripa\n"
20712                 "\n"
20713                 "    Redacted form:  General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
20714                 "    ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
20715                 "    styline, legline, labx, laby, labz)\n"
20716                 "           Perl/PDL: plstripc(xmin, xmax, xjump, ymin, ymax, xlpos,\n"
20717                 "    ylpos, y_ascl, acc, colbox, collab, colline, styline, id, xspec,\n"
20718                 "    ypsec, legline, labx, laby, labtop)\n"
20719                 "\n"
20720                 "\n"
20721                 "    This function is used in example 17. \n"
20722                 "\n"
20723                 "\n"
20724                 "\n"
20725                 "SYNOPSIS:\n"
20726                 "\n"
20727                 "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
20728                 "\n"
20729                 "ARGUMENTS:\n"
20730                 "\n"
20731                 "    id (PLINT *, output) :    Identification number of strip chart to use\n"
20732                 "    on plstripa and plstripd. \n"
20733                 "\n"
20734                 "    xspec (const char *, input) :    X-axis specification as in plbox. \n"
20735                 "\n"
20736                 "    yspec (const char *, input) :    Y-axis specification as in plbox. \n"
20737                 "\n"
20738                 "    xmin (PLFLT, input) :    Initial coordinates of plot box; they will\n"
20739                 "    change as data are added. \n"
20740                 "\n"
20741                 "    xmax (PLFLT, input) :    Initial coordinates of plot box; they will\n"
20742                 "    change as data are added. \n"
20743                 "\n"
20744                 "    xjump (PLFLT, input) :    When x attains xmax, the length of the plot\n"
20745                 "    is multiplied by the factor (1 + \n"
20746                 "    xjump). \n"
20747                 "\n"
20748                 "    ymin (PLFLT, input) :    Initial coordinates of plot box; they will\n"
20749                 "    change as data are added. \n"
20750                 "\n"
20751                 "    ymax (PLFLT, input) :    Initial coordinates of plot box; they will\n"
20752                 "    change as data are added. \n"
20753                 "\n"
20754                 "    xlpos (PLFLT, input) :    X legend box position (range from 0 to 1). \n"
20755                 "\n"
20756                 "    ylpos (PLFLT, input) :    Y legend box position (range from 0 to 1). \n"
20757                 "\n"
20758                 "    y_ascl (PLBOOL, input) :    Autoscale y between x jumps if y_ascl is\n"
20759                 "    true, otherwise not. \n"
20760                 "\n"
20761                 "    acc (PLBOOL, input) :    Accumulate strip plot if acc is true,\n"
20762                 "    otherwise slide display. \n"
20763                 "\n"
20764                 "    colbox (PLINT, input) :    Plot box color index (cmap0). \n"
20765                 "\n"
20766                 "    collab (PLINT, input) :    Legend color index (cmap0). \n"
20767                 "\n"
20768                 "    colline (const PLINT *, input) :    Pointer to array with color\n"
20769                 "    indices (cmap0) for the 4 pens. \n"
20770                 "\n"
20771                 "    styline (const PLINT *, input) :    Pointer to array with line styles\n"
20772                 "    for the 4 pens. \n"
20773                 "\n"
20774                 "    legline (const char **, input) :    Pointer to character array\n"
20775                 "    containing legends for the 4 pens. \n"
20776                 "\n"
20777                 "    labx (const char *, input) :    X-axis label. \n"
20778                 "\n"
20779                 "    laby (const char *, input) :    Y-axis label. \n"
20780                 "\n"
20781                 "    labtop (const char *, input) :    Plot title. \n"
20782                 "\n"
20783                 ""},
20784          { (char *)"plstripd", _wrap_plstripd, METH_VARARGS, (char *)"\n"
20785                 "Deletes and releases memory used by a strip chart \n"
20786                 "\n"
20787                 "DESCRIPTION:\n"
20788                 "\n"
20789                 "    Deletes and releases memory used by a strip chart. \n"
20790                 "\n"
20791                 "    Redacted form: plstripd(id)\n"
20792                 "\n"
20793                 "    This function is used in example 17. \n"
20794                 "\n"
20795                 "\n"
20796                 "\n"
20797                 "SYNOPSIS:\n"
20798                 "\n"
20799                 "plstripd(id)\n"
20800                 "\n"
20801                 "ARGUMENTS:\n"
20802                 "\n"
20803                 "    id (PLINT, input) :    Identification number of strip chart to delete. \n"
20804                 "\n"
20805                 ""},
20806          { (char *)"plstyl", _wrap_plstyl, METH_VARARGS, (char *)"\n"
20807                 "Set line style \n"
20808                 "\n"
20809                 "DESCRIPTION:\n"
20810                 "\n"
20811                 "    This sets up the line style for all lines subsequently drawn.  A line\n"
20812                 "    consists of segments in which the pen is alternately down and up. The\n"
20813                 "    lengths of these segments are passed in the arrays mark and space\n"
20814                 "    respectively.  The number of mark-space pairs is specified by nms. In\n"
20815                 "    order to return the line style to the default continuous line, plstyl\n"
20816                 "    should be called with nms=0.(see also pllsty) \n"
20817                 "\n"
20818                 "    Redacted form: plstyl(mark, space)\n"
20819                 "\n"
20820                 "    This function is used in examples 1,9,14. \n"
20821                 "\n"
20822                 "\n"
20823                 "\n"
20824                 "SYNOPSIS:\n"
20825                 "\n"
20826                 "plstyl(nms, mark, space)\n"
20827                 "\n"
20828                 "ARGUMENTS:\n"
20829                 "\n"
20830                 "    nms (PLINT, input) :    The number of mark and space elements in a\n"
20831                 "    line.  Thus a simple broken line can be obtained by setting nms=1.\n"
20832                 "     A continuous line is specified by setting nms=0. \n"
20833                 "\n"
20834                 "    mark (const PLINT *, input) :    Pointer to array with the lengths of\n"
20835                 "    the segments during which the pen is down, measured in\n"
20836                 "    micrometers. \n"
20837                 "\n"
20838                 "    space (const PLINT *, input) :    Pointer to array with the lengths of\n"
20839                 "    the segments during which the pen is up, measured in micrometers. \n"
20840                 "\n"
20841                 ""},
20842          { (char *)"plsvect", _wrap_plsvect, METH_VARARGS, (char *)"\n"
20843                 "Set arrow style for vector plots \n"
20844                 "\n"
20845                 "DESCRIPTION:\n"
20846                 "\n"
20847                 "    Set the style for the arrow used by plvect to plot vectors. \n"
20848                 "\n"
20849                 "    Redacted form: plsvect(arrowx, arrowy, fill)\n"
20850                 "\n"
20851                 "    This function is used in example 22. \n"
20852                 "\n"
20853                 "\n"
20854                 "\n"
20855                 "SYNOPSIS:\n"
20856                 "\n"
20857                 "plsvect(arrowx, arrowy, npts, fill)\n"
20858                 "\n"
20859                 "ARGUMENTS:\n"
20860                 "\n"
20861                 "    arrowx, arrowy (const PLFLT *,input) :    Pointers to a pair of arrays\n"
20862                 "    containing the x and y points which make up the arrow. The arrow\n"
20863                 "    is plotted by joining these points to form a polygon. The scaling\n"
20864                 "    assumes that the x and y points in the arrow lie in the range -0.5\n"
20865                 "    <= x,y <= 0.5. If both    arrowx and arrowy are NULL then the arrow\n"
20866                 "    style will be reset to its default. \n"
20867                 "\n"
20868                 "    npts (PLINT,input) :    Number of points in the arrays arrowx and\n"
20869                 "    arrowy. \n"
20870                 "\n"
20871                 "    fill (PLBOOL,input) :    If fill is true then the arrow is closed, if\n"
20872                 "    fill is false then the arrow is open. \n"
20873                 "\n"
20874                 ""},
20875          { (char *)"plsvpa", _wrap_plsvpa, METH_VARARGS, (char *)"\n"
20876                 "Specify viewport in absolute coordinates \n"
20877                 "\n"
20878                 "DESCRIPTION:\n"
20879                 "\n"
20880                 "    Alternate routine to plvpor for setting up the viewport.  This routine\n"
20881                 "    should be used only if the viewport is required to have a definite\n"
20882                 "    size in millimeters.  The routine plgspa is useful for finding out the\n"
20883                 "    size of the current subpage. \n"
20884                 "\n"
20885                 "    Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
20886                 "\n"
20887                 "    This function is used in example 10. \n"
20888                 "\n"
20889                 "\n"
20890                 "\n"
20891                 "SYNOPSIS:\n"
20892                 "\n"
20893                 "plsvpa(xmin, xmax, ymin, ymax)\n"
20894                 "\n"
20895                 "ARGUMENTS:\n"
20896                 "\n"
20897                 "    xmin (PLFLT, input) :    The distance of the left-hand edge of the\n"
20898                 "    viewport from the left-hand edge of the subpage in millimeters. \n"
20899                 "\n"
20900                 "    xmax (PLFLT, input) :    The distance of the right-hand edge of the\n"
20901                 "    viewport from the left-hand edge of the subpage in millimeters. \n"
20902                 "\n"
20903                 "    ymin (PLFLT, input) :    The distance of the bottom edge of the\n"
20904                 "    viewport from the bottom edge of the subpage in millimeters. \n"
20905                 "\n"
20906                 "    ymax (PLFLT, input) :    The distance of the top edge of the viewport\n"
20907                 "    from the bottom edge of the subpage in millimeters. \n"
20908                 "\n"
20909                 ""},
20910          { (char *)"plsxax", _wrap_plsxax, METH_VARARGS, (char *)"\n"
20911                 "Set x axis parameters \n"
20912                 "\n"
20913                 "DESCRIPTION:\n"
20914                 "\n"
20915                 "    Sets values of the digmax and digits flags for the x axis. See the\n"
20916                 "    PLplot documentation for more information. \n"
20917                 "\n"
20918                 "    Redacted form: plsxax(digmax, digits)\n"
20919                 "\n"
20920                 "    This function is used in example 31. \n"
20921                 "\n"
20922                 "\n"
20923                 "\n"
20924                 "SYNOPSIS:\n"
20925                 "\n"
20926                 "plsxax(digmax, digits)\n"
20927                 "\n"
20928                 "ARGUMENTS:\n"
20929                 "\n"
20930                 "    digmax (PLINT, input) :    Variable to set the maximum number of\n"
20931                 "    digits for the x axis.    If nonzero, the printed label will be\n"
20932                 "    switched to a floating point representation when the number of\n"
20933                 "    digits exceeds digmax. \n"
20934                 "\n"
20935                 "    digits (PLINT, input) :    Field digits value.  Currently, changing\n"
20936                 "    its value here has no effect since it is set only by plbox or\n"
20937                 "    plbox3.  However, the user may obtain its value after a call to\n"
20938                 "    either of these functions by calling plgxax. \n"
20939                 "\n"
20940                 ""},
20941          { (char *)"plsyax", _wrap_plsyax, METH_VARARGS, (char *)"\n"
20942                 "Set y axis parameters \n"
20943                 "\n"
20944                 "DESCRIPTION:\n"
20945                 "\n"
20946                 "    Identical to plsxax, except that arguments are flags for y axis. See\n"
20947                 "    the description of plsxax for more detail. \n"
20948                 "\n"
20949                 "    Redacted form: plsyax(digmax, digits)\n"
20950                 "\n"
20951                 "    This function is used in examples 1,14,31. \n"
20952                 "\n"
20953                 "\n"
20954                 "\n"
20955                 "SYNOPSIS:\n"
20956                 "\n"
20957                 "plsyax(digmax, digits)\n"
20958                 "\n"
20959                 "ARGUMENTS:\n"
20960                 "\n"
20961                 "    digmax (PLINT, input) :    Variable to set the maximum number of\n"
20962                 "    digits for the y axis.    If nonzero, the printed label will be\n"
20963                 "    switched to a floating point representation when the number of\n"
20964                 "    digits exceeds digmax. \n"
20965                 "\n"
20966                 "    digits (PLINT, input) :    Field digits value.  Currently, changing\n"
20967                 "    its value here has no effect since it is set only by plbox or\n"
20968                 "    plbox3.  However, the user may obtain its value after a call to\n"
20969                 "    either of these functions by calling plgyax. \n"
20970                 "\n"
20971                 ""},
20972          { (char *)"plsym", _wrap_plsym, METH_VARARGS, (char *)"\n"
20973                 "Plot a glyph at the specified points \n"
20974                 "\n"
20975                 "DESCRIPTION:\n"
20976                 "\n"
20977                 "    Plot a glyph at the specified points.  (This function is largely\n"
20978                 "    superseded by plstring which gives access to many[!]  more glyphs.) \n"
20979                 "\n"
20980                 "    Redacted form: plsym(x, y, code)\n"
20981                 "\n"
20982                 "    This function is used in example 7. \n"
20983                 "\n"
20984                 "\n"
20985                 "\n"
20986                 "SYNOPSIS:\n"
20987                 "\n"
20988                 "plsym(n, x, y, code)\n"
20989                 "\n"
20990                 "ARGUMENTS:\n"
20991                 "\n"
20992                 "    n (PLINT, input) :      Number of points in the x and y arrays. \n"
20993                 "\n"
20994                 "    x (const PLFLT *, input) :      Pointer to an array with X coordinates\n"
20995                 "    of points. \n"
20996                 "\n"
20997                 "    y (const PLFLT *, input) :      Pointer to an array with Y coordinates\n"
20998                 "    of points. \n"
20999                 "\n"
21000                 "    code (PLINT, input) :    Hershey symbol code corresponding to a glyph\n"
21001                 "    to be plotted at each of the n points. \n"
21002                 "\n"
21003                 ""},
21004          { (char *)"plszax", _wrap_plszax, METH_VARARGS, (char *)"\n"
21005                 "Set z axis parameters \n"
21006                 "\n"
21007                 "DESCRIPTION:\n"
21008                 "\n"
21009                 "    Identical to plsxax, except that arguments are flags for z axis. See\n"
21010                 "    the description of plsxax for more detail. \n"
21011                 "\n"
21012                 "    Redacted form: plszax(digmax, digits)\n"
21013                 "\n"
21014                 "    This function is used in example 31. \n"
21015                 "\n"
21016                 "\n"
21017                 "\n"
21018                 "SYNOPSIS:\n"
21019                 "\n"
21020                 "plszax(digmax, digits)\n"
21021                 "\n"
21022                 "ARGUMENTS:\n"
21023                 "\n"
21024                 "    digmax (PLINT, input) :    Variable to set the maximum number of\n"
21025                 "    digits for the z axis.    If nonzero, the printed label will be\n"
21026                 "    switched to a floating point representation when the number of\n"
21027                 "    digits exceeds digmax. \n"
21028                 "\n"
21029                 "    digits (PLINT, input) :    Field digits value.  Currently, changing\n"
21030                 "    its value here has no effect since it is set only by plbox or\n"
21031                 "    plbox3.  However, the user may obtain its value after a call to\n"
21032                 "    either of these functions by calling plgzax. \n"
21033                 "\n"
21034                 ""},
21035          { (char *)"pltext", _wrap_pltext, METH_VARARGS, (char *)"\n"
21036                 "Switch to text screen \n"
21037                 "\n"
21038                 "DESCRIPTION:\n"
21039                 "\n"
21040                 "    Sets an interactive device to text mode, used in conjunction with\n"
21041                 "    plgra to allow graphics and text to be interspersed.  On a device\n"
21042                 "    which supports separate text and graphics windows, this command causes\n"
21043                 "    control to be switched to the text window. This can be useful for\n"
21044                 "    printing diagnostic messages or getting user input, which would\n"
21045                 "    otherwise interfere with the plots.  The program must switch back to\n"
21046                 "    the graphics window before issuing plot commands, as the text (or\n"
21047                 "    console) device will probably become quite confused otherwise.  If\n"
21048                 "    already in text mode, this command is ignored.  It is also ignored on\n"
21049                 "    devices which only support a single window or use a different method\n"
21050                 "    for shifting focus (see also plgra). \n"
21051                 "\n"
21052                 "    Redacted form: pltext()\n"
21053                 "\n"
21054                 "    This function is used in example 1. \n"
21055                 "\n"
21056                 "\n"
21057                 "\n"
21058                 "SYNOPSIS:\n"
21059                 "\n"
21060                 "pltext()\n"
21061                 "\n"
21062                 ""},
21063          { (char *)"pltimefmt", _wrap_pltimefmt, METH_VARARGS, (char *)"\n"
21064                 "Set format for date / time labels \n"
21065                 "\n"
21066                 "DESCRIPTION:\n"
21067                 "\n"
21068                 "    Sets the format for date / time labels. To enable date / time format\n"
21069                 "    labels see the options to plbox and plenv. \n"
21070                 "\n"
21071                 "    Redacted form: pltimefmt(fmt)\n"
21072                 "\n"
21073                 "    This function is used in example 29. \n"
21074                 "\n"
21075                 "\n"
21076                 "\n"
21077                 "SYNOPSIS:\n"
21078                 "\n"
21079                 "pltimefmt(fmt)\n"
21080                 "\n"
21081                 "ARGUMENTS:\n"
21082                 "\n"
21083                 "    fmt (const char *, fmt) :     This string is passed directly to the\n"
21084                 "    system strftime. See the system documentation for a full list of\n"
21085                 "    conversion specifications for your system. All conversion\n"
21086                 "    specifications take the form of a '%' character followed by\n"
21087                 "    further conversion specification character. All other text is\n"
21088                 "    printed as-is. Common options include: %c: The preferred date and\n"
21089                 "    time representation for the current locale.  \n"
21090                 "        %d: The day of the month as a decimal number.  \n"
21091                 "        %H: The hour as a decimal number using a 24-hour clock.  \n"
21092                 "        %j: The day of the year as a decimal number.  \n"
21093                 "        %m: The month as a decimal number.    \n"
21094                 "        %M: The minute as a decimal number.  \n"
21095                 "        %S: The second as a decimal number.  \n"
21096                 "        %y: The year as a decimal number without a century.  \n"
21097                 "        %Y: The year  as a decimal number including a century.  \n"
21098                 "\n"
21099                 ""},
21100          { (char *)"plvasp", _wrap_plvasp, METH_VARARGS, (char *)"\n"
21101                 "Specify viewport using aspect ratio only \n"
21102                 "\n"
21103                 "DESCRIPTION:\n"
21104                 "\n"
21105                 "    Sets the viewport so that the ratio of the length of the y axis to\n"
21106                 "    that of the x axis is equal to aspect. \n"
21107                 "\n"
21108                 "    Redacted form: plvasp(aspect)\n"
21109                 "\n"
21110                 "    This function is used in example 13. \n"
21111                 "\n"
21112                 "\n"
21113                 "\n"
21114                 "SYNOPSIS:\n"
21115                 "\n"
21116                 "plvasp(aspect)\n"
21117                 "\n"
21118                 "ARGUMENTS:\n"
21119                 "\n"
21120                 "    aspect (PLFLT, input) :    Ratio of length of y axis to length of x\n"
21121                 "    axis. \n"
21122                 "\n"
21123                 ""},
21124          { (char *)"plvect", _wrap_plvect, METH_VARARGS, (char *)"\n"
21125                 "Vector plot \n"
21126                 "\n"
21127                 "DESCRIPTION:\n"
21128                 "\n"
21129                 "    Draws a vector plot of the vector (\n"
21130                 "    u[\n"
21131                 "    nx][\n"
21132                 "    ny],\n"
21133                 "    v[\n"
21134                 "    nx][\n"
21135                 "    ny]). The scaling factor for the vectors is given by scale. A\n"
21136                 "    transformation routine pointed to by pltr with a pointer pltr_data for\n"
21137                 "    additional data required by the transformation routine is used to map\n"
21138                 "    indices within the array to the world coordinates. The style of the\n"
21139                 "    vector arrow may be set using plsvect. \n"
21140                 "\n"
21141                 "    Redacted form: plvect(u, v, scale, pltr, pltr_data)\n"
21142                 "\n"
21143                 "    This function is used in example 22. \n"
21144                 "\n"
21145                 "\n"
21146                 "\n"
21147                 "SYNOPSIS:\n"
21148                 "\n"
21149                 "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
21150                 "\n"
21151                 "ARGUMENTS:\n"
21152                 "\n"
21153                 "    u, v (const PLFLT * const *, input) :    Pointers to a pair of\n"
21154                 "    vectored two-dimensional arrays containing the x and y components\n"
21155                 "    of the vector data to be plotted. \n"
21156                 "\n"
21157                 "    nx, ny (PLINT, input) :    Physical dimensions of the arrays u and v. \n"
21158                 "\n"
21159                 "    scale (PLFLT, input) :    Parameter to control the scaling factor of\n"
21160                 "    the vectors for plotting. If scale = 0 then the scaling factor is\n"
21161                 "    automatically calculated for the data. If scale < 0 then the\n"
21162                 "    scaling factor is automatically calculated for the data and then\n"
21163                 "    multiplied by -\n"
21164                 "    scale. If scale > 0 then the scaling factor is set to scale. \n"
21165                 "\n"
21166                 "    pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
21167                 "      Pointer to function that defines transformation between indices\n"
21168                 "    in array z and the world coordinates (C only).    Transformation\n"
21169                 "    functions are provided in the PLplot library: pltr0 for identity\n"
21170                 "    mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n"
21171                 "    defined by one- and two-dimensional arrays.  In addition,\n"
21172                 "    user-supplied routines for the transformation can be used as well.\n"
21173                 "     Examples of all of these approaches are given in the PLplot\n"
21174                 "    documentation. The transformation function should have the form\n"
21175                 "    given by any of pltr0, pltr1, or pltr2. \n"
21176                 "\n"
21177                 "    pltr_data (PLPointer, input) :    Extra parameter to help pass\n"
21178                 "    information to pltr0, pltr1, pltr2, or whatever routine that is\n"
21179                 "    externally supplied. \n"
21180                 "\n"
21181                 ""},
21182          { (char *)"plvpas", _wrap_plvpas, METH_VARARGS, (char *)"\n"
21183                 "Specify viewport using coordinates and aspect ratio \n"
21184                 "\n"
21185                 "DESCRIPTION:\n"
21186                 "\n"
21187                 "    Device-independent routine for setting up the viewport.  The viewport\n"
21188                 "    is chosen to be the largest with the given aspect ratio that fits\n"
21189                 "    within the specified region (in terms of normalized subpage\n"
21190                 "    coordinates).  This routine is functionally equivalent to plvpor when\n"
21191                 "    a ``natural'' aspect ratio (0.0) is chosen.  Unlike plvasp, this\n"
21192                 "    routine reserves no extra space at the edges for labels. \n"
21193                 "\n"
21194                 "    Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
21195                 "\n"
21196                 "    This function is used in example 9. \n"
21197                 "\n"
21198                 "\n"
21199                 "\n"
21200                 "SYNOPSIS:\n"
21201                 "\n"
21202                 "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
21203                 "\n"
21204                 "ARGUMENTS:\n"
21205                 "\n"
21206                 "    xmin (PLFLT, input) :    The normalized subpage coordinate of the\n"
21207                 "    left-hand edge of the viewport. \n"
21208                 "\n"
21209                 "    xmax (PLFLT, input) :    The normalized subpage coordinate of the\n"
21210                 "    right-hand edge of the viewport. \n"
21211                 "\n"
21212                 "    ymin (PLFLT, input) :    The normalized subpage coordinate of the\n"
21213                 "    bottom edge of the viewport. \n"
21214                 "\n"
21215                 "    ymax (PLFLT, input) :    The normalized subpage coordinate of the top\n"
21216                 "    edge of the viewport. \n"
21217                 "\n"
21218                 "    aspect (PLFLT, input) :    Ratio of length of y axis to length of x\n"
21219                 "    axis. \n"
21220                 "\n"
21221                 ""},
21222          { (char *)"plvpor", _wrap_plvpor, METH_VARARGS, (char *)"\n"
21223                 "Specify viewport using coordinates \n"
21224                 "\n"
21225                 "DESCRIPTION:\n"
21226                 "\n"
21227                 "    Device-independent routine for setting up the viewport.  This defines\n"
21228                 "    the viewport in terms of normalized subpage coordinates which run from\n"
21229                 "    0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
21230                 "    current subpage.  Use the alternate routine plsvpa in order to create\n"
21231                 "    a viewport of a definite size. \n"
21232                 "\n"
21233                 "    Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
21234                 "\n"
21235                 "    This function is used in examples\n"
21236                 "    2,6-8,10,11,15,16,18,21,23,24,26,27,31. \n"
21237                 "\n"
21238                 "\n"
21239                 "\n"
21240                 "SYNOPSIS:\n"
21241                 "\n"
21242                 "plvpor(xmin, xmax, ymin, ymax)\n"
21243                 "\n"
21244                 "ARGUMENTS:\n"
21245                 "\n"
21246                 "    xmin (PLFLT, input) :    The normalized subpage coordinate of the\n"
21247                 "    left-hand edge of the viewport. \n"
21248                 "\n"
21249                 "    xmax (PLFLT, input) :    The normalized subpage coordinate of the\n"
21250                 "    right-hand edge of the viewport. \n"
21251                 "\n"
21252                 "    ymin (PLFLT, input) :    The normalized subpage coordinate of the\n"
21253                 "    bottom edge of the viewport. \n"
21254                 "\n"
21255                 "    ymax (PLFLT, input) :    The normalized subpage coordinate of the top\n"
21256                 "    edge of the viewport. \n"
21257                 "\n"
21258                 ""},
21259          { (char *)"plvsta", _wrap_plvsta, METH_VARARGS, (char *)"\n"
21260                 "Select standard viewport \n"
21261                 "\n"
21262                 "DESCRIPTION:\n"
21263                 "\n"
21264                 "    Sets up a standard viewport, leaving a left-hand margin of seven\n"
21265                 "    character heights, and four character heights around the other three\n"
21266                 "    sides. \n"
21267                 "\n"
21268                 "    Redacted form: plvsta()\n"
21269                 "\n"
21270                 "    This function is used in examples 1,12,14,17,25,29. \n"
21271                 "\n"
21272                 "\n"
21273                 "\n"
21274                 "SYNOPSIS:\n"
21275                 "\n"
21276                 "plvsta()\n"
21277                 "\n"
21278                 ""},
21279          { (char *)"plw3d", _wrap_plw3d, METH_VARARGS, (char *)"\n"
21280                 "Set up window for 3-d plotting \n"
21281                 "\n"
21282                 "DESCRIPTION:\n"
21283                 "\n"
21284                 "    Sets up a window for a three-dimensional surface plot within the\n"
21285                 "    currently defined two-dimensional window.  The enclosing box for the\n"
21286                 "    surface plot defined by xmin, xmax, ymin, ymax, zmin and zmax in\n"
21287                 "    user-coordinate space is mapped into a box of world coordinate size\n"
21288                 "    basex by basey by height so that xmin maps to -\n"
21289                 "    basex/2, xmax maps to basex/2, ymin maps to -\n"
21290                 "    basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
21291                 "     The resulting world-coordinate box is then viewed by an observer at\n"
21292                 "    altitude alt and azimuth az.  This routine must be called before\n"
21293                 "    plbox3 or plot3d.  For a more complete description of\n"
21294                 "    three-dimensional plotting see the PLplot documentation. \n"
21295                 "\n"
21296                 "    Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
21297                 "    zmin, zmax, alt, az)\n"
21298                 "\n"
21299                 "    This function is examples 8,11,18,21. \n"
21300                 "\n"
21301                 "\n"
21302                 "\n"
21303                 "SYNOPSIS:\n"
21304                 "\n"
21305                 "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
21306                 "\n"
21307                 "ARGUMENTS:\n"
21308                 "\n"
21309                 "    basex (PLFLT, input) :    The x coordinate size of the\n"
21310                 "    world-coordinate box. \n"
21311                 "\n"
21312                 "    basey (PLFLT, input) :    The y coordinate size of the\n"
21313                 "    world-coordinate box. \n"
21314                 "\n"
21315                 "    height (PLFLT, input) :    The z coordinate size of the\n"
21316                 "    world-coordinate box. \n"
21317                 "\n"
21318                 "    xmin (PLFLT, input) :    The minimum user x coordinate value. \n"
21319                 "\n"
21320                 "    xmax (PLFLT, input) :    The maximum user x coordinate value. \n"
21321                 "\n"
21322                 "    ymin (PLFLT, input) :    The minimum user y coordinate value. \n"
21323                 "\n"
21324                 "    ymax (PLFLT, input) :    The maximum user y coordinate value. \n"
21325                 "\n"
21326                 "    zmin (PLFLT, input) :    The minimum user z coordinate value. \n"
21327                 "\n"
21328                 "    zmax (PLFLT, input) :    The maximum user z coordinate value. \n"
21329                 "\n"
21330                 "    alt (PLFLT, input) :    The viewing altitude in degrees above the XY\n"
21331                 "    plane. \n"
21332                 "\n"
21333                 "    az (PLFLT, input) :    The viewing azimuth in degrees.  When az=0, the\n"
21334                 "    observer is looking face onto the ZX plane, and as az is\n"
21335                 "    increased, the observer moves clockwise around the box when viewed\n"
21336                 "    from above the XY plane. \n"
21337                 "\n"
21338                 ""},
21339          { (char *)"plwidth", _wrap_plwidth, METH_VARARGS, (char *)"\n"
21340                 "Set pen width \n"
21341                 "\n"
21342                 "DESCRIPTION:\n"
21343                 "\n"
21344                 "    Sets the pen width. \n"
21345                 "\n"
21346                 "    Redacted form: plwidth(width)\n"
21347                 "\n"
21348                 "    This function is used in examples 1,2. \n"
21349                 "\n"
21350                 "\n"
21351                 "\n"
21352                 "SYNOPSIS:\n"
21353                 "\n"
21354                 "plwidth(width)\n"
21355                 "\n"
21356                 "ARGUMENTS:\n"
21357                 "\n"
21358                 "    width (PLFLT, input) :    The desired pen width.  If width is negative\n"
21359                 "    or the same as the previous value no action is taken. width = 0.\n"
21360                 "    should be interpreted as as the minimum valid pen width for the\n"
21361                 "    device.  The interpretation of positive width values is also\n"
21362                 "    device dependent. \n"
21363                 "\n"
21364                 ""},
21365          { (char *)"plwind", _wrap_plwind, METH_VARARGS, (char *)"\n"
21366                 "Specify world coordinates of viewport boundaries \n"
21367                 "\n"
21368                 "DESCRIPTION:\n"
21369                 "\n"
21370                 "    Sets up the world coordinates of the edges of the viewport. \n"
21371                 "\n"
21372                 "    Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
21373                 "\n"
21374                 "    This function is used in examples 1,2,4,6-12,14-16,18,21,23-27,29,31. \n"
21375                 "\n"
21376                 "\n"
21377                 "\n"
21378                 "SYNOPSIS:\n"
21379                 "\n"
21380                 "plwind(xmin, xmax, ymin, ymax)\n"
21381                 "\n"
21382                 "ARGUMENTS:\n"
21383                 "\n"
21384                 "    xmin (PLFLT, input) :    The world x coordinate of the left-hand edge\n"
21385                 "    of the viewport. \n"
21386                 "\n"
21387                 "    xmax (PLFLT, input) :    The world x coordinate of the right-hand edge\n"
21388                 "    of the viewport. \n"
21389                 "\n"
21390                 "    ymin (PLFLT, input) :    The world y coordinate of the bottom edge of\n"
21391                 "    the viewport. \n"
21392                 "\n"
21393                 "    ymax (PLFLT, input) :    The world y coordinate of the top edge of the\n"
21394                 "    viewport. \n"
21395                 "\n"
21396                 ""},
21397          { (char *)"plxormod", _wrap_plxormod, METH_VARARGS, (char *)"\n"
21398                 "Enter or leave xor mode \n"
21399                 "\n"
21400                 "DESCRIPTION:\n"
21401                 "\n"
21402                 "    Enter (when mode is true)  or leave (when mode is false) xor mode for\n"
21403                 "    those drivers (e.g., the xwin driver) that support it.  Enables\n"
21404                 "    erasing plots by drawing twice the same line, symbol, etc. If driver\n"
21405                 "    is not capable of xor operation it returns a status of false. \n"
21406                 "\n"
21407                 "    Redacted form: plxormod(mode, status)\n"
21408                 "\n"
21409                 "    This function is used in examples 1,20. \n"
21410                 "\n"
21411                 "\n"
21412                 "\n"
21413                 "SYNOPSIS:\n"
21414                 "\n"
21415                 "plxormod(mode, status)\n"
21416                 "\n"
21417                 "ARGUMENTS:\n"
21418                 "\n"
21419                 "    mode (PLBOOL, input) :    mode is true means enter xor mode and  mode\n"
21420                 "    is false means leave xor mode. \n"
21421                 "\n"
21422                 "    status (PLBOOL *, output) :    Pointer to status. Returned    modestatus\n"
21423                 "    of true (false) means driver is capable (incapable) of xor mode. \n"
21424                 "\n"
21425                 ""},
21426          { (char *)"plmap", _wrap_plmap, METH_VARARGS, (char *)"\n"
21427                 "Plot continental outline in world coordinates \n"
21428                 "\n"
21429                 "DESCRIPTION:\n"
21430                 "\n"
21431                 "    Plots continental outlines in world coordinates. examples/c/x19c\n"
21432                 "    demonstrates how to use this  function to create different\n"
21433                 "    projections. \n"
21434                 "\n"
21435                 "    Redacted form:  General: plmap(mapform, type, minlong, maxlong,\n"
21436                 "    minlat, maxlat)\n"
21437                 "           F95, Java, Perl/PDL, Python: Not implemented? \n"
21438                 "\n"
21439                 "\n"
21440                 "    This function is used in example 19. \n"
21441                 "\n"
21442                 "\n"
21443                 "\n"
21444                 "SYNOPSIS:\n"
21445                 "\n"
21446                 "plmap(mapform, type, minlong, maxlong, minlat, maxlat)\n"
21447                 "\n"
21448                 "ARGUMENTS:\n"
21449                 "\n"
21450                 "    mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) :    A user\n"
21451                 "    supplied function to transform the coordinate  longitudes and\n"
21452                 "    latitudes to a plot coordinate system.     By using this transform,\n"
21453                 "    we can change from a longitude,  latitude coordinate to a polar\n"
21454                 "    stereographic project, for  example.  Initially, x[0]..[n-1] are\n"
21455                 "    the longitudes and y[0]..y[n-1]  are the corresponding latitudes. \n"
21456                 "    After the call to mapform(), x[]  and y[] should be replaced by\n"
21457                 "    the corresponding plot coordinates.   If no transform is desired,\n"
21458                 "    mapform can be replaced by NULL. \n"
21459                 "\n"
21460                 "    type (const char *, input) :    type is a character string. The value\n"
21461                 "    of this parameter determines the type of background. The possible\n"
21462                 "    values are: \"globe\" -- continental outlines \n"
21463                 "        \"usa\" -- USA and state boundaries \n"
21464                 "        \"cglobe\" -- continental outlines and countries \n"
21465                 "        \"usaglobe\" -- USA, state boundaries and continental outlines \n"
21466                 "\n"
21467                 "\n"
21468                 "    minlong (PLFLT, input) :    The value of the longitude on the left\n"
21469                 "    side of the plot.  The value of minlong must be less than the\n"
21470                 "    value of maxlong, and the  quantity maxlong-minlong must be less\n"
21471                 "    than or equal to 360. \n"
21472                 "\n"
21473                 "    maxlong (PLFLT, input) :    The value of the longitude on the right\n"
21474                 "    side of the plot. \n"
21475                 "\n"
21476                 "    minlat (PLFLT, input) :    The minimum latitude to be plotted on the\n"
21477                 "    background.   One can always use -90.0 as the boundary outside the\n"
21478                 "    plot window  will be automatically eliminated.    However, the\n"
21479                 "    program will be  faster if one can reduce the size of the\n"
21480                 "    background plotted. \n"
21481                 "\n"
21482                 "    maxlat (PLFLT, input) :    The maximum latitudes to be plotted on the\n"
21483                 "    background.   One can always use 90.0 as the boundary outside the\n"
21484                 "    plot window  will be automatically eliminated. \n"
21485                 "\n"
21486                 ""},
21487          { (char *)"plmeridians", _wrap_plmeridians, METH_VARARGS, (char *)"\n"
21488                 "Plot latitude and longitude lines \n"
21489                 "\n"
21490                 "DESCRIPTION:\n"
21491                 "\n"
21492                 "    Displays latitude and longitude on the current plot.  The lines are\n"
21493                 "    plotted in the current color and line style. \n"
21494                 "\n"
21495                 "    Redacted form:  General: plmeridians(mapform, dlong, dlat, minlong,\n"
21496                 "    maxlong, minlat, maxlat)\n"
21497                 "           F95, Java, Perl/PDL, Python: Not implemented? \n"
21498                 "\n"
21499                 "\n"
21500                 "    This function is used in example 19. \n"
21501                 "\n"
21502                 "\n"
21503                 "\n"
21504                 "SYNOPSIS:\n"
21505                 "\n"
21506                 "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
21507                 "\n"
21508                 "ARGUMENTS:\n"
21509                 "\n"
21510                 "    mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) :    A user\n"
21511                 "    supplied function to transform the coordinate  longitudes and\n"
21512                 "    latitudes to a plot coordinate system.     By using this transform,\n"
21513                 "    we can change from a longitude,  latitude coordinate to a polar\n"
21514                 "    stereographic project, for  example.  Initially, x[0]..[n-1] are\n"
21515                 "    the longitudes and y[0]..y[n-1]  are the corresponding latitudes. \n"
21516                 "    After the call to mapform(), x[]  and y[] should be replaced by\n"
21517                 "    the corresponding plot coordinates.   If no transform is desired,\n"
21518                 "    mapform can be replaced by NULL. \n"
21519                 "\n"
21520                 "    dlong (PLFLT, input) :    The interval in degrees at which the\n"
21521                 "    longitude lines are to be plotted. \n"
21522                 "\n"
21523                 "    dlat (PLFLT, input) :    The interval in degrees at which the latitude\n"
21524                 "    lines are to be plotted. \n"
21525                 "\n"
21526                 "    minlong (PLFLT, input) :    The value of the longitude on the left\n"
21527                 "    side of the plot.  The value of minlong must be less than the\n"
21528                 "    value of maxlong, and the  quantity maxlong-minlong must be less\n"
21529                 "    than or equal to 360. \n"
21530                 "\n"
21531                 "    maxlong (PLFLT, input) :    The value of the longitude on the right\n"
21532                 "    side of the plot. \n"
21533                 "\n"
21534                 "    minlat (PLFLT, input) :    The minimum latitude to be plotted on the\n"
21535                 "    background.   One can always use -90.0 as the boundary outside the\n"
21536                 "    plot window  will be automatically eliminated.    However, the\n"
21537                 "    program will be  faster if one can reduce the size of the\n"
21538                 "    background plotted. \n"
21539                 "\n"
21540                 "    maxlat (PLFLT, input) :    The maximum latitudes to be plotted on the\n"
21541                 "    background.   One can always use 90.0 as the boundary outside the\n"
21542                 "    plot window  will be automatically eliminated. \n"
21543                 "\n"
21544                 ""},
21545          { (char *)"plimage", _wrap_plimage, METH_VARARGS, (char *)"\n"
21546                 "Plot a 2D matrix using cmap1 with automatic colour adjustment \n"
21547                 "\n"
21548                 "DESCRIPTION:\n"
21549                 "\n"
21550                 "    Plot a 2D matrix using color palette 1.  The color scale is\n"
21551                 "    automatically adjusted to use the maximum and minimum values in idata\n"
21552                 "    as valuemin and valuemax in a call to plimagefr. \n"
21553                 "\n"
21554                 "    Redacted form:  General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
21555                 "    zmax, Dxmin, Dxmax, Dymin, Dymax) \n"
21556                 "\n"
21557                 "\n"
21558                 "    This function is used in example 20. \n"
21559                 "\n"
21560                 "\n"
21561                 "\n"
21562                 "SYNOPSIS:\n"
21563                 "\n"
21564                 "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
21565                 "\n"
21566                 "ARGUMENTS:\n"
21567                 "\n"
21568                 "    idata (const PLFLT * const *, input) :    A 2D array of values\n"
21569                 "    (intensities) to plot.    Should have dimensions idata[nx][ny]. \n"
21570                 "\n"
21571                 "    nx, ny (PLINT, input) :    Dimensions of idata \n"
21572                 "\n"
21573                 "    xmin, xmax, ymin, ymax (PLFLT, input) :    Plot coordinates to stretch\n"
21574                 "    the image data to.  idata[0][0] corresponds to (xmin, ymin) and\n"
21575                 "    idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n"
21576                 "\n"
21577                 "    zmin, zmax (PLFLT, input) :    Only data between zmin and zmax\n"
21578                 "    (inclusive) will be plotted. \n"
21579                 "\n"
21580                 "    Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) :    Plot only the window of\n"
21581                 "    points whose plot coordinates fall inside the window of (Dxmin,\n"
21582                 "    Dymin) to (Dxmax, Dymax). \n"
21583                 "\n"
21584                 ""},
21585          { (char *)"plimagefr", _wrap_plimagefr, METH_VARARGS, (char *)"\n"
21586                 "Plot a 2D matrix using cmap1 \n"
21587                 "\n"
21588                 "DESCRIPTION:\n"
21589                 "\n"
21590                 "    Plot a 2D matrix using cmap1. \n"
21591                 "\n"
21592                 "    Redacted form:  General: plimagefr(idata, xmin, xmax, ymin, ymax,\n"
21593                 "    zmin, zmax, valuemin, valuemax, pltr, pltr_data) \n"
21594                 "\n"
21595                 "\n"
21596                 "    This function is used in example 20. \n"
21597                 "\n"
21598                 "\n"
21599                 "\n"
21600                 "SYNOPSIS:\n"
21601                 "\n"
21602                 "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
21603                 "\n"
21604                 "ARGUMENTS:\n"
21605                 "\n"
21606                 "    idata (const PLFLT * const *, input) :    A 2D array of values\n"
21607                 "    (intensities) to plot.    Should have dimensions idata[nx][ny]. \n"
21608                 "\n"
21609                 "    nx, ny (PLINT, input) :    Dimensions of idata \n"
21610                 "\n"
21611                 "    xmin, xmax, ymin, ymax (PLFLT, input) :    Stretch image data to these\n"
21612                 "    Plot coordinates.  idata[0][0] corresponds to (xmin, ymin) and\n"
21613                 "    idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n"
21614                 "\n"
21615                 "    zmin, zmax (PLFLT, input) :    Only data between zmin and zmax\n"
21616                 "    (inclusive) will be plotted. \n"
21617                 "\n"
21618                 "    valuemin, valuemax (PLFLT, input) :    The minimum and maximum data\n"
21619                 "    values to use for value to color mappings.  A datum equal to or\n"
21620                 "    less than valuemin will be plotted with color 0.0, while a datum\n"
21621                 "    equal to or greater than valuemax will be plotted with color 1.0. \n"
21622                 "    Data between valuemin and valuemax map linearly to colors between\n"
21623                 "    0.0 and 1.0. \n"
21624                 "\n"
21625                 "    pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n"
21626                 "      Pointer to function that defines a transformation between the\n"
21627                 "    data in the array idata and world coordinates.    An input\n"
21628                 "    coordinate of (0, 0) corresponds to the \"top-left\" corner of idata\n"
21629                 "    while (nx, ny) corresponds to the \"bottom-right\" corner of idata. \n"
21630                 "    Some transformation functions are provided in the PLplot library:\n"
21631                 "    pltr0 for identity mapping, and pltr1 and pltr2 for arbitrary\n"
21632                 "    mappings respectively defined by one- and two-dimensional arrays. \n"
21633                 "    In addition, user-supplied routines for the transformation can be\n"
21634                 "    used as well.  Examples of all of these approaches are given in\n"
21635                 "    the PLplot documentation.  The transformation function should have\n"
21636                 "    the form given by any of pltr0, pltr1, or pltr2. \n"
21637                 "\n"
21638                 "    pltr_data (PLPointer, input) :    Extra parameter to help pass\n"
21639                 "    information to pltr0, pltr1, pltr2, or whatever routine is\n"
21640                 "    externally supplied. \n"
21641                 "\n"
21642                 ""},
21643          { (char *)"plClearOpts", _wrap_plClearOpts, METH_VARARGS, NULL},
21644          { (char *)"plResetOpts", _wrap_plResetOpts, METH_VARARGS, NULL},
21645          { (char *)"plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL},
21646          { (char *)"plOptUsage", _wrap_plOptUsage, METH_VARARGS, NULL},
21647          { (char *)"plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_VARARGS, NULL},
21648          { (char *)"plGetCursor", _wrap_plGetCursor, METH_VARARGS, NULL},
21649          { NULL, NULL, 0, NULL }
21650 };
21651 
21652 
21653 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21654 
21655 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0};
21656 static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0};
21657 static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0};
21658 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
21659 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
21660 static swig_type_info _swigt__p_f_double_double__int = {"_p_f_double_double__int", "defined_func|int (*)(double,double)", 0, 0, (void*)0, 0};
21661 static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void = {"_p_f_double_double_p_double_p_double_p_void__void", "ct_func|pltr_func|void (*)(double,double,double *,double *,void *)", 0, 0, (void*)0, 0};
21662 static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void = {"_p_f_int_double_p_char_int_p_void__void", "void (*)(int,double,char *,int,void *)|label_func", 0, 0, (void*)0, 0};
21663 static swig_type_info _swigt__p_f_int_p_double_p_double__void = {"_p_f_int_p_double_p_double__void", "mapform_func|void (*)(int,double *,double *)", 0, 0, (void*)0, 0};
21664 static swig_type_info _swigt__p_f_int_p_q_const__double_p_q_const__double__void = {"_p_f_int_p_q_const__double_p_q_const__double__void", "void (*)(int,double const *,double const *)|fill_func", 0, 0, (void*)0, 0};
21665 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
21666 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
21667 static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
21668 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
21669 
21670 static swig_type_info *swig_type_initial[] = {
21671   &_swigt__p_PLGraphicsIn,
21672   &_swigt__p_PLcGrid,
21673   &_swigt__p_PLcGrid2,
21674   &_swigt__p_char,
21675   &_swigt__p_double,
21676   &_swigt__p_f_double_double__int,
21677   &_swigt__p_f_double_double_p_double_p_double_p_void__void,
21678   &_swigt__p_f_int_double_p_char_int_p_void__void,
21679   &_swigt__p_f_int_p_double_p_double__void,
21680   &_swigt__p_f_int_p_q_const__double_p_q_const__double__void,
21681   &_swigt__p_int,
21682   &_swigt__p_p_char,
21683   &_swigt__p_p_double,
21684   &_swigt__p_unsigned_int,
21685 };
21686 
21687 static swig_cast_info _swigc__p_PLGraphicsIn[] = {  {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
21688 static swig_cast_info _swigc__p_PLcGrid[] = {  {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}};
21689 static swig_cast_info _swigc__p_PLcGrid2[] = {  {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}};
21690 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
21691 static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
21692 static swig_cast_info _swigc__p_f_double_double__int[] = {  {&_swigt__p_f_double_double__int, 0, 0, 0},{0, 0, 0, 0}};
21693 static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[] = {  {&_swigt__p_f_double_double_p_double_p_double_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
21694 static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[] = {  {&_swigt__p_f_int_double_p_char_int_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
21695 static swig_cast_info _swigc__p_f_int_p_double_p_double__void[] = {  {&_swigt__p_f_int_p_double_p_double__void, 0, 0, 0},{0, 0, 0, 0}};
21696 static swig_cast_info _swigc__p_f_int_p_q_const__double_p_q_const__double__void[] = {  {&_swigt__p_f_int_p_q_const__double_p_q_const__double__void, 0, 0, 0},{0, 0, 0, 0}};
21697 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
21698 static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
21699 static swig_cast_info _swigc__p_p_double[] = {  {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
21700 static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
21701 
21702 static swig_cast_info *swig_cast_initial[] = {
21703   _swigc__p_PLGraphicsIn,
21704   _swigc__p_PLcGrid,
21705   _swigc__p_PLcGrid2,
21706   _swigc__p_char,
21707   _swigc__p_double,
21708   _swigc__p_f_double_double__int,
21709   _swigc__p_f_double_double_p_double_p_double_p_void__void,
21710   _swigc__p_f_int_double_p_char_int_p_void__void,
21711   _swigc__p_f_int_p_double_p_double__void,
21712   _swigc__p_f_int_p_q_const__double_p_q_const__double__void,
21713   _swigc__p_int,
21714   _swigc__p_p_char,
21715   _swigc__p_p_double,
21716   _swigc__p_unsigned_int,
21717 };
21718 
21719 
21720 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
21721 
21722 static swig_const_info swig_const_table[] = {
21723 {0, 0, 0, 0.0, 0, 0}};
21724 
21725 #ifdef __cplusplus
21726 }
21727 #endif
21728 /* -----------------------------------------------------------------------------
21729  * Type initialization:
21730  * This problem is tough by the requirement that no dynamic
21731  * memory is used. Also, since swig_type_info structures store pointers to
21732  * swig_cast_info structures and swig_cast_info structures store pointers back
21733  * to swig_type_info structures, we need some lookup code at initialization.
21734  * The idea is that swig generates all the structures that are needed.
21735  * The runtime then collects these partially filled structures.
21736  * The SWIG_InitializeModule function takes these initial arrays out of
21737  * swig_module, and does all the lookup, filling in the swig_module.types
21738  * array with the correct data and linking the correct swig_cast_info
21739  * structures together.
21740  *
21741  * The generated swig_type_info structures are assigned statically to an initial
21742  * array. We just loop through that array, and handle each type individually.
21743  * First we lookup if this type has been already loaded, and if so, use the
21744  * loaded structure instead of the generated one. Then we have to fill in the
21745  * cast linked list. The cast data is initially stored in something like a
21746  * two-dimensional array. Each row corresponds to a type (there are the same
21747  * number of rows as there are in the swig_type_initial array). Each entry in
21748  * a column is one of the swig_cast_info structures for that type.
21749  * The cast_initial array is actually an array of arrays, because each row has
21750  * a variable number of columns. So to actually build the cast linked list,
21751  * we find the array of casts associated with the type, and loop through it
21752  * adding the casts to the list. The one last trick we need to do is making
21753  * sure the type pointer in the swig_cast_info struct is correct.
21754  *
21755  * First off, we lookup the cast->type name to see if it is already loaded.
21756  * There are three cases to handle:
21757  *  1) If the cast->type has already been loaded AND the type we are adding
21758  *     casting info to has not been loaded (it is in this module), THEN we
21759  *     replace the cast->type pointer with the type pointer that has already
21760  *     been loaded.
21761  *  2) If BOTH types (the one we are adding casting info to, and the
21762  *     cast->type) are loaded, THEN the cast info has already been loaded by
21763  *     the previous module so we just ignore it.
21764  *  3) Finally, if cast->type has not already been loaded, then we add that
21765  *     swig_cast_info to the linked list (because the cast->type) pointer will
21766  *     be correct.
21767  * ----------------------------------------------------------------------------- */
21768 
21769 #ifdef __cplusplus
21770 extern "C" {
21771 #if 0
21772 } /* c-mode */
21773 #endif
21774 #endif
21775 
21776 #if 0
21777 #define SWIGRUNTIME_DEBUG
21778 #endif
21779 
21780 
21781 SWIGRUNTIME void
21782 SWIG_InitializeModule(void *clientdata) {
21783   size_t i;
21784   swig_module_info *module_head, *iter;
21785   int found, init;
21786   
21787   /* check to see if the circular list has been setup, if not, set it up */
21788   if (swig_module.next==0) {
21789     /* Initialize the swig_module */
21790     swig_module.type_initial = swig_type_initial;
21791     swig_module.cast_initial = swig_cast_initial;
21792     swig_module.next = &swig_module;
21793     init = 1;
21794   } else {
21795     init = 0;
21796   }
21797   
21798   /* Try and load any already created modules */
21799   module_head = SWIG_GetModule(clientdata);
21800   if (!module_head) {
21801     /* This is the first module loaded for this interpreter */
21802     /* so set the swig module into the interpreter */
21803     SWIG_SetModule(clientdata, &swig_module);
21804     module_head = &swig_module;
21805   } else {
21806     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
21807     found=0;
21808     iter=module_head;
21809     do {
21810       if (iter==&swig_module) {
21811         found=1;
21812         break;
21813       }
21814       iter=iter->next;
21815     } while (iter!= module_head);
21816     
21817     /* if the is found in the list, then all is done and we may leave */
21818     if (found) return;
21819     /* otherwise we must add out module into the list */
21820     swig_module.next = module_head->next;
21821     module_head->next = &swig_module;
21822   }
21823   
21824   /* When multiple interpreters are used, a module could have already been initialized in
21825        a different interpreter, but not yet have a pointer in this interpreter.
21826        In this case, we do not want to continue adding types... everything should be
21827        set up already */
21828   if (init == 0) return;
21829   
21830   /* Now work on filling in swig_module.types */
21831 #ifdef SWIGRUNTIME_DEBUG
21832   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
21833 #endif
21834   for (i = 0; i < swig_module.size; ++i) {
21835     swig_type_info *type = 0;
21836     swig_type_info *ret;
21837     swig_cast_info *cast;
21838     
21839 #ifdef SWIGRUNTIME_DEBUG
21840     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
21841 #endif
21842     
21843     /* if there is another module already loaded */
21844     if (swig_module.next != &swig_module) {
21845       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
21846     }
21847     if (type) {
21848       /* Overwrite clientdata field */
21849 #ifdef SWIGRUNTIME_DEBUG
21850       printf("SWIG_InitializeModule: found type %s\n", type->name);
21851 #endif
21852       if (swig_module.type_initial[i]->clientdata) {
21853         type->clientdata = swig_module.type_initial[i]->clientdata;
21854 #ifdef SWIGRUNTIME_DEBUG
21855         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
21856 #endif
21857       }
21858     } else {
21859       type = swig_module.type_initial[i];
21860     }
21861     
21862     /* Insert casting types */
21863     cast = swig_module.cast_initial[i];
21864     while (cast->type) {
21865       /* Don't need to add information already in the list */
21866       ret = 0;
21867 #ifdef SWIGRUNTIME_DEBUG
21868       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
21869 #endif
21870       if (swig_module.next != &swig_module) {
21871         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
21872 #ifdef SWIGRUNTIME_DEBUG
21873         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
21874 #endif
21875       }
21876       if (ret) {
21877         if (type == swig_module.type_initial[i]) {
21878 #ifdef SWIGRUNTIME_DEBUG
21879           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
21880 #endif
21881           cast->type = ret;
21882           ret = 0;
21883         } else {
21884           /* Check for casting already in the list */
21885           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
21886 #ifdef SWIGRUNTIME_DEBUG
21887           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
21888 #endif
21889           if (!ocast) ret = 0;
21890         }
21891       }
21892       
21893       if (!ret) {
21894 #ifdef SWIGRUNTIME_DEBUG
21895         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
21896 #endif
21897         if (type->cast) {
21898           type->cast->prev = cast;
21899           cast->next = type->cast;
21900         }
21901         type->cast = cast;
21902       }
21903       cast++;
21904     }
21905     /* Set entry in modules->types array equal to the type */
21906     swig_module.types[i] = type;
21907   }
21908   swig_module.types[i] = 0;
21909   
21910 #ifdef SWIGRUNTIME_DEBUG
21911   printf("**** SWIG_InitializeModule: Cast List ******\n");
21912   for (i = 0; i < swig_module.size; ++i) {
21913     int j = 0;
21914     swig_cast_info *cast = swig_module.cast_initial[i];
21915     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
21916     while (cast->type) {
21917       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
21918       cast++;
21919       ++j;
21920     }
21921     printf("---- Total casts: %d\n",j);
21922   }
21923   printf("**** SWIG_InitializeModule: Cast List ******\n");
21924 #endif
21925 }
21926 
21927 /* This function will propagate the clientdata field of type to
21928 * any new swig_type_info structures that have been added into the list
21929 * of equivalent types.  It is like calling
21930 * SWIG_TypeClientData(type, clientdata) a second time.
21931 */
21932 SWIGRUNTIME void
21933 SWIG_PropagateClientData(void) {
21934   size_t i;
21935   swig_cast_info *equiv;
21936   static int init_run = 0;
21937   
21938   if (init_run) return;
21939   init_run = 1;
21940   
21941   for (i = 0; i < swig_module.size; i++) {
21942     if (swig_module.types[i]->clientdata) {
21943       equiv = swig_module.types[i]->cast;
21944       while (equiv) {
21945         if (!equiv->converter) {
21946           if (equiv->type && !equiv->type->clientdata)
21947           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
21948         }
21949         equiv = equiv->next;
21950       }
21951     }
21952   }
21953 }
21954 
21955 #ifdef __cplusplus
21956 #if 0
21957 {
21958   /* c-mode */
21959 #endif
21960 }
21961 #endif
21962 
21963 
21964 
21965 #ifdef __cplusplus
21966 extern "C" {
21967 #endif
21968   
21969   /* Python-specific SWIG API */
21970 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
21971 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
21972 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
21973   
21974   /* -----------------------------------------------------------------------------
21975    * global variable support code.
21976    * ----------------------------------------------------------------------------- */
21977   
21978   typedef struct swig_globalvar {
21979     char       *name;                  /* Name of global variable */
21980     PyObject *(*get_attr)(void);       /* Return the current value */
21981     int       (*set_attr)(PyObject *); /* Set the value */
21982     struct swig_globalvar *next;
21983   } swig_globalvar;
21984   
21985   typedef struct swig_varlinkobject {
21986     PyObject_HEAD
21987     swig_globalvar *vars;
21988   } swig_varlinkobject;
21989   
21990   SWIGINTERN PyObject *
21991   swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
21992 #if PY_VERSION_HEX >= 0x03000000
21993     return PyUnicode_InternFromString("<Swig global variables>");
21994 #else
21995     return PyString_FromString("<Swig global variables>");
21996 #endif
21997   }
21998   
21999   SWIGINTERN PyObject *
22000   swig_varlink_str(swig_varlinkobject *v) {
22001 #if PY_VERSION_HEX >= 0x03000000
22002     PyObject *str = PyUnicode_InternFromString("(");
22003     PyObject *tail;
22004     PyObject *joined;
22005     swig_globalvar *var;
22006     for (var = v->vars; var; var=var->next) {
22007       tail = PyUnicode_FromString(var->name);
22008       joined = PyUnicode_Concat(str, tail);
22009       Py_DecRef(str);
22010       Py_DecRef(tail);
22011       str = joined;
22012       if (var->next) {
22013         tail = PyUnicode_InternFromString(", ");
22014         joined = PyUnicode_Concat(str, tail);
22015         Py_DecRef(str);
22016         Py_DecRef(tail);
22017         str = joined;
22018       }
22019     }
22020     tail = PyUnicode_InternFromString(")");
22021     joined = PyUnicode_Concat(str, tail);
22022     Py_DecRef(str);
22023     Py_DecRef(tail);
22024     str = joined;
22025 #else
22026     PyObject *str = PyString_FromString("(");
22027     swig_globalvar *var;
22028     for (var = v->vars; var; var=var->next) {
22029       PyString_ConcatAndDel(&str,PyString_FromString(var->name));
22030       if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
22031     }
22032     PyString_ConcatAndDel(&str,PyString_FromString(")"));
22033 #endif
22034     return str;
22035   }
22036   
22037   SWIGINTERN int
22038   swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
22039     char *tmp;
22040     PyObject *str = swig_varlink_str(v);
22041     fprintf(fp,"Swig global variables ");
22042     fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
22043     SWIG_Python_str_DelForPy3(tmp);
22044     Py_DECREF(str);
22045     return 0;
22046   }
22047   
22048   SWIGINTERN void
22049   swig_varlink_dealloc(swig_varlinkobject *v) {
22050     swig_globalvar *var = v->vars;
22051     while (var) {
22052       swig_globalvar *n = var->next;
22053       free(var->name);
22054       free(var);
22055       var = n;
22056     }
22057   }
22058   
22059   SWIGINTERN PyObject *
22060   swig_varlink_getattr(swig_varlinkobject *v, char *n) {
22061     PyObject *res = NULL;
22062     swig_globalvar *var = v->vars;
22063     while (var) {
22064       if (strcmp(var->name,n) == 0) {
22065         res = (*var->get_attr)();
22066         break;
22067       }
22068       var = var->next;
22069     }
22070     if (res == NULL && !PyErr_Occurred()) {
22071       PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
22072     }
22073     return res;
22074   }
22075   
22076   SWIGINTERN int
22077   swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22078     int res = 1;
22079     swig_globalvar *var = v->vars;
22080     while (var) {
22081       if (strcmp(var->name,n) == 0) {
22082         res = (*var->set_attr)(p);
22083         break;
22084       }
22085       var = var->next;
22086     }
22087     if (res == 1 && !PyErr_Occurred()) {
22088       PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
22089     }
22090     return res;
22091   }
22092   
22093   SWIGINTERN PyTypeObject*
22094   swig_varlink_type(void) {
22095     static char varlink__doc__[] = "Swig var link object";
22096     static PyTypeObject varlink_type;
22097     static int type_init = 0;
22098     if (!type_init) {
22099       const PyTypeObject tmp = {
22100         /* PyObject header changed in Python 3 */
22101 #if PY_VERSION_HEX >= 0x03000000
22102         PyVarObject_HEAD_INIT(NULL, 0)
22103 #else
22104         PyObject_HEAD_INIT(NULL)
22105         0,                                  /* ob_size */
22106 #endif
22107         (char *)"swigvarlink",              /* tp_name */
22108         sizeof(swig_varlinkobject),         /* tp_basicsize */
22109         0,                                  /* tp_itemsize */
22110         (destructor) swig_varlink_dealloc,  /* tp_dealloc */
22111         (printfunc) swig_varlink_print,     /* tp_print */
22112         (getattrfunc) swig_varlink_getattr, /* tp_getattr */
22113         (setattrfunc) swig_varlink_setattr, /* tp_setattr */
22114         0,                                  /* tp_compare */
22115         (reprfunc) swig_varlink_repr,       /* tp_repr */
22116         0,                                  /* tp_as_number */
22117         0,                                  /* tp_as_sequence */
22118         0,                                  /* tp_as_mapping */
22119         0,                                  /* tp_hash */
22120         0,                                  /* tp_call */
22121         (reprfunc) swig_varlink_str,        /* tp_str */
22122         0,                                  /* tp_getattro */
22123         0,                                  /* tp_setattro */
22124         0,                                  /* tp_as_buffer */
22125         0,                                  /* tp_flags */
22126         varlink__doc__,                     /* tp_doc */
22127         0,                                  /* tp_traverse */
22128         0,                                  /* tp_clear */
22129         0,                                  /* tp_richcompare */
22130         0,                                  /* tp_weaklistoffset */
22131 #if PY_VERSION_HEX >= 0x02020000
22132         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
22133 #endif
22134 #if PY_VERSION_HEX >= 0x02030000
22135         0,                                  /* tp_del */
22136 #endif
22137 #if PY_VERSION_HEX >= 0x02060000
22138         0,                                  /* tp_version */
22139 #endif
22140 #ifdef COUNT_ALLOCS
22141         0,0,0,0                             /* tp_alloc -> tp_next */
22142 #endif
22143       };
22144       varlink_type = tmp;
22145       type_init = 1;
22146 #if PY_VERSION_HEX < 0x02020000
22147       varlink_type.ob_type = &PyType_Type;
22148 #else
22149       if (PyType_Ready(&varlink_type) < 0)
22150       return NULL;
22151 #endif
22152     }
22153     return &varlink_type;
22154   }
22155   
22156   /* Create a variable linking object for use later */
22157   SWIGINTERN PyObject *
22158   SWIG_Python_newvarlink(void) {
22159     swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
22160     if (result) {
22161       result->vars = 0;
22162     }
22163     return ((PyObject*) result);
22164   }
22165   
22166   SWIGINTERN void 
22167   SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22168     swig_varlinkobject *v = (swig_varlinkobject *) p;
22169     swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22170     if (gv) {
22171       size_t size = strlen(name)+1;
22172       gv->name = (char *)malloc(size);
22173       if (gv->name) {
22174         strncpy(gv->name,name,size);
22175         gv->get_attr = get_attr;
22176         gv->set_attr = set_attr;
22177         gv->next = v->vars;
22178       }
22179     }
22180     v->vars = gv;
22181   }
22182   
22183   SWIGINTERN PyObject *
22184   SWIG_globals(void) {
22185     static PyObject *_SWIG_globals = 0; 
22186     if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();  
22187     return _SWIG_globals;
22188   }
22189   
22190   /* -----------------------------------------------------------------------------
22191    * constants/methods manipulation
22192    * ----------------------------------------------------------------------------- */
22193   
22194   /* Install Constants */
22195   SWIGINTERN void
22196   SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
22197     PyObject *obj = 0;
22198     size_t i;
22199     for (i = 0; constants[i].type; ++i) {
22200       switch(constants[i].type) {
22201       case SWIG_PY_POINTER:
22202         obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
22203         break;
22204       case SWIG_PY_BINARY:
22205         obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
22206         break;
22207       default:
22208         obj = 0;
22209         break;
22210       }
22211       if (obj) {
22212         PyDict_SetItemString(d, constants[i].name, obj);
22213         Py_DECREF(obj);
22214       }
22215     }
22216   }
22217   
22218   /* -----------------------------------------------------------------------------*/
22219   /* Fix SwigMethods to carry the callback ptrs when needed */
22220   /* -----------------------------------------------------------------------------*/
22221   
22222   SWIGINTERN void
22223   SWIG_Python_FixMethods(PyMethodDef *methods,
22224     swig_const_info *const_table,
22225     swig_type_info **types,
22226     swig_type_info **types_initial) {
22227     size_t i;
22228     for (i = 0; methods[i].ml_name; ++i) {
22229       const char *c = methods[i].ml_doc;
22230       if (c && (c = strstr(c, "swig_ptr: "))) {
22231         int j;
22232         swig_const_info *ci = 0;
22233         const char *name = c + 10;
22234         for (j = 0; const_table[j].type; ++j) {
22235           if (strncmp(const_table[j].name, name, 
22236               strlen(const_table[j].name)) == 0) {
22237             ci = &(const_table[j]);
22238             break;
22239           }
22240         }
22241         if (ci) {
22242           void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
22243           if (ptr) {
22244             size_t shift = (ci->ptype) - types;
22245             swig_type_info *ty = types_initial[shift];
22246             size_t ldoc = (c - methods[i].ml_doc);
22247             size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
22248             char *ndoc = (char*)malloc(ldoc + lptr + 10);
22249             if (ndoc) {
22250               char *buff = ndoc;
22251               strncpy(buff, methods[i].ml_doc, ldoc);
22252               buff += ldoc;
22253               strncpy(buff, "swig_ptr: ", 10);
22254               buff += 10;
22255               SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
22256               methods[i].ml_doc = ndoc;
22257             }
22258           }
22259         }
22260       }
22261     }
22262   } 
22263   
22264 #ifdef __cplusplus
22265 }
22266 #endif
22267 
22268 /* -----------------------------------------------------------------------------*
22269  *  Partial Init method
22270  * -----------------------------------------------------------------------------*/
22271 
22272 #ifdef __cplusplus
22273 extern "C"
22274 #endif
22275 
22276 SWIGEXPORT 
22277 #if PY_VERSION_HEX >= 0x03000000
22278 PyObject*
22279 #else
22280 void
22281 #endif
22282 SWIG_init(void) {
22283   PyObject *m, *d, *md;
22284 #if PY_VERSION_HEX >= 0x03000000
22285   static struct PyModuleDef SWIG_module = {
22286 # if PY_VERSION_HEX >= 0x03020000
22287     PyModuleDef_HEAD_INIT,
22288 # else
22289     {
22290       PyObject_HEAD_INIT(NULL)
22291       NULL, /* m_init */
22292       0,    /* m_index */
22293       NULL, /* m_copy */
22294     },
22295 # endif
22296     (char *) SWIG_name,
22297     NULL,
22298     -1,
22299     SwigMethods,
22300     NULL,
22301     NULL,
22302     NULL,
22303     NULL
22304   };
22305 #endif
22306   
22307 #if defined(SWIGPYTHON_BUILTIN)
22308   static SwigPyClientData SwigPyObject_clientdata = {
22309     0, 0, 0, 0, 0, 0, 0
22310   };
22311   static PyGetSetDef this_getset_def = {
22312     (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
22313   };
22314   static SwigPyGetSet thisown_getset_closure = {
22315     (PyCFunction) SwigPyObject_own,
22316     (PyCFunction) SwigPyObject_own
22317   };
22318   static PyGetSetDef thisown_getset_def = {
22319     (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
22320   };
22321   PyObject *metatype_args;
22322   PyTypeObject *builtin_pytype;
22323   int builtin_base_count;
22324   swig_type_info *builtin_basetype;
22325   PyObject *tuple;
22326   PyGetSetDescrObject *static_getset;
22327   PyTypeObject *metatype;
22328   SwigPyClientData *cd;
22329   PyObject *public_interface, *public_symbol;
22330   PyObject *this_descr;
22331   PyObject *thisown_descr;
22332   int i;
22333   
22334   (void)builtin_pytype;
22335   (void)builtin_base_count;
22336   (void)builtin_basetype;
22337   (void)tuple;
22338   (void)static_getset;
22339   
22340   /* metatype is used to implement static member variables. */
22341   metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
22342   assert(metatype_args);
22343   metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
22344   assert(metatype);
22345   Py_DECREF(metatype_args);
22346   metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
22347   assert(PyType_Ready(metatype) >= 0);
22348 #endif
22349   
22350   /* Fix SwigMethods to carry the callback ptrs when needed */
22351   SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
22352   
22353 #if PY_VERSION_HEX >= 0x03000000
22354   m = PyModule_Create(&SWIG_module);
22355 #else
22356   m = Py_InitModule((char *) SWIG_name, SwigMethods);
22357 #endif
22358   md = d = PyModule_GetDict(m);
22359   (void)md;
22360   
22361   SWIG_InitializeModule(0);
22362   
22363 #ifdef SWIGPYTHON_BUILTIN
22364   SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
22365   assert(SwigPyObject_stype);
22366   cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
22367   if (!cd) {
22368     SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
22369     SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce();
22370   } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) {
22371     PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
22372 # if PY_VERSION_HEX >= 0x03000000
22373     return NULL;
22374 # else
22375     return;
22376 # endif
22377   }
22378   
22379   /* All objects have a 'this' attribute */
22380   this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
22381   (void)this_descr;
22382   
22383   /* All objects have a 'thisown' attribute */
22384   thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
22385   (void)thisown_descr;
22386   
22387   public_interface = PyList_New(0);
22388   public_symbol = 0;
22389   (void)public_symbol;
22390   
22391   PyDict_SetItemString(md, "__all__", public_interface);
22392   Py_DECREF(public_interface);
22393   for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
22394   SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
22395   for (i = 0; swig_const_table[i].name != 0; ++i)
22396   SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
22397 #endif
22398   
22399   SWIG_InstallConstants(d,swig_const_table);
22400   
22401   
22402   import_array();
22403   
22404   SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1)));
22405   SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
22406   SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3)));
22407   SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4)));
22408   SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5)));
22409   SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6)));
22410   SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7)));
22411   SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8)));
22412   SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9)));
22413   SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10)));
22414   SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11)));
22415   SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12)));
22416   SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13)));
22417   SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14)));
22418   SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
22419   SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16)));
22420   SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
22421   SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18)));
22422   SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19)));
22423   SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
22424   SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21)));
22425   SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
22426   SWIG_Python_SetConstant(d, "PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
22427   SWIG_Python_SetConstant(d, "PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
22428   SWIG_Python_SetConstant(d, "PLESC_SETBGFG",SWIG_From_int((int)(25)));
22429   SWIG_Python_SetConstant(d, "PLESC_DEVINIT",SWIG_From_int((int)(26)));
22430   SWIG_Python_SetConstant(d, "PLESC_GETBACKEND",SWIG_From_int((int)(27)));
22431   SWIG_Python_SetConstant(d, "PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
22432   SWIG_Python_SetConstant(d, "PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
22433   SWIG_Python_SetConstant(d, "PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
22434   SWIG_Python_SetConstant(d, "PLESC_END_TEXT",SWIG_From_int((int)(31)));
22435   SWIG_Python_SetConstant(d, "PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
22436   SWIG_Python_SetConstant(d, "PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
22437   SWIG_Python_SetConstant(d, "PLESC_ARC",SWIG_From_int((int)(34)));
22438   SWIG_Python_SetConstant(d, "PLESC_GRADIENT",SWIG_From_int((int)(35)));
22439   SWIG_Python_SetConstant(d, "PLESC_MODESET",SWIG_From_int((int)(36)));
22440   SWIG_Python_SetConstant(d, "PLESC_MODEGET",SWIG_From_int((int)(37)));
22441   SWIG_Python_SetConstant(d, "PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
22442   SWIG_Python_SetConstant(d, "PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
22443   SWIG_Python_SetConstant(d, "PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
22444   SWIG_Python_SetConstant(d, "PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
22445   SWIG_Python_SetConstant(d, "PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
22446   SWIG_Python_SetConstant(d, "PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
22447   SWIG_Python_SetConstant(d, "ZEROW2B",SWIG_From_int((int)(1)));
22448   SWIG_Python_SetConstant(d, "ZEROW2D",SWIG_From_int((int)(2)));
22449   SWIG_Python_SetConstant(d, "ONEW2B",SWIG_From_int((int)(3)));
22450   SWIG_Python_SetConstant(d, "ONEW2D",SWIG_From_int((int)(4)));
22451   SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1)));
22452   SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2)));
22453   SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1)));
22454   SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2)));
22455   SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3)));
22456   SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
22457   SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
22458   SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
22459   SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
22460   SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
22461   SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
22462   SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
22463   SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400)));
22464   SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
22465   SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
22466   SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
22467   SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
22468   SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
22469   SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
22470   SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
22471   SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
22472   SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
22473   SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
22474   SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
22475   SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
22476   SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
22477   SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
22478   SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
22479   SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
22480   SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
22481   SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
22482   SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
22483   SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0)));
22484   SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
22485   SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2)));
22486   SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
22487   SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
22488   SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
22489   SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
22490   SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
22491   SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
22492   SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
22493   SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16)));
22494   SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64)));
22495   SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42))));
22496   SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
22497   SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
22498   SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
22499   SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
22500   SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
22501   SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
22502   SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
22503   SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1)));
22504   SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2)));
22505   SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3)));
22506   SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4)));
22507   SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5)));
22508   SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6)));
22509   SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
22510   SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
22511   SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
22512   SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
22513   SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
22514   SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
22515   SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
22516   SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
22517   SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
22518   SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
22519   SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
22520   SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
22521   SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
22522   SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
22523   SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
22524   SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
22525   SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
22526   SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
22527   SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
22528   SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
22529   SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
22530   SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
22531   SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
22532   SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
22533   SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
22534   SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
22535   SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
22536   SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
22537   SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
22538   SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
22539   SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
22540   SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
22541   SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
22542   SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
22543   SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
22544   SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
22545   SWIG_Python_SetConstant(d, "PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
22546   SWIG_Python_SetConstant(d, "PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
22547   SWIG_Python_SetConstant(d, "PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
22548   SWIG_Python_SetConstant(d, "PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
22549   SWIG_Python_SetConstant(d, "PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
22550   SWIG_Python_SetConstant(d, "PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
22551   SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x001)));
22552   SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x002)));
22553   SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x003)));
22554   SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x004)));
22555   SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x008)));
22556   SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x010)));
22557   SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x020)));
22558   SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x040)));
22559   SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x080)));
22560   SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100)));
22561 #if PY_VERSION_HEX >= 0x03000000
22562   return m;
22563 #else
22564   return;
22565 #endif
22566 }
22567 
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Defines