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

plplotjavacJAVA_wrap.c

Go to the documentation of this file.
00001 /* ----------------------------------------------------------------------------
00002  * This file was automatically generated by SWIG (http://www.swig.org).
00003  * Version 1.3.40
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 SWIGJAVA
00012 
00013 /* -----------------------------------------------------------------------------
00014  *  This section contains generic SWIG labels for method/variable
00015  *  declarations/attributes, and other compiler dependent labels.
00016  * ----------------------------------------------------------------------------- */
00017 
00018 /* template workaround for compilers that cannot correctly implement the C++ standard */
00019 #ifndef SWIGTEMPLATEDISAMBIGUATOR
00020 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
00021 #  define SWIGTEMPLATEDISAMBIGUATOR template
00022 # elif defined(__HP_aCC)
00023 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
00024 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
00025 #  define SWIGTEMPLATEDISAMBIGUATOR template
00026 # else
00027 #  define SWIGTEMPLATEDISAMBIGUATOR
00028 # endif
00029 #endif
00030 
00031 /* inline attribute */
00032 #ifndef SWIGINLINE
00033 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
00034 #   define SWIGINLINE inline
00035 # else
00036 #   define SWIGINLINE
00037 # endif
00038 #endif
00039 
00040 /* attribute recognised by some compilers to avoid 'unused' warnings */
00041 #ifndef SWIGUNUSED
00042 # if defined(__GNUC__)
00043 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
00044 #     define SWIGUNUSED __attribute__ ((__unused__)) 
00045 #   else
00046 #     define SWIGUNUSED
00047 #   endif
00048 # elif defined(__ICC)
00049 #   define SWIGUNUSED __attribute__ ((__unused__)) 
00050 # else
00051 #   define SWIGUNUSED 
00052 # endif
00053 #endif
00054 
00055 #ifndef SWIG_MSC_UNSUPPRESS_4505
00056 # if defined(_MSC_VER)
00057 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
00058 # endif 
00059 #endif
00060 
00061 #ifndef SWIGUNUSEDPARM
00062 # ifdef __cplusplus
00063 #   define SWIGUNUSEDPARM(p)
00064 # else
00065 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
00066 # endif
00067 #endif
00068 
00069 /* internal SWIG method */
00070 #ifndef SWIGINTERN
00071 # define SWIGINTERN static SWIGUNUSED
00072 #endif
00073 
00074 /* internal inline SWIG method */
00075 #ifndef SWIGINTERNINLINE
00076 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
00077 #endif
00078 
00079 /* exporting methods */
00080 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
00081 #  ifndef GCC_HASCLASSVISIBILITY
00082 #    define GCC_HASCLASSVISIBILITY
00083 #  endif
00084 #endif
00085 
00086 #ifndef SWIGEXPORT
00087 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
00088 #   if defined(STATIC_LINKED)
00089 #     define SWIGEXPORT
00090 #   else
00091 #     define SWIGEXPORT __declspec(dllexport)
00092 #   endif
00093 # else
00094 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
00095 #     define SWIGEXPORT __attribute__ ((visibility("default")))
00096 #   else
00097 #     define SWIGEXPORT
00098 #   endif
00099 # endif
00100 #endif
00101 
00102 /* calling conventions for Windows */
00103 #ifndef SWIGSTDCALL
00104 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
00105 #   define SWIGSTDCALL __stdcall
00106 # else
00107 #   define SWIGSTDCALL
00108 # endif 
00109 #endif
00110 
00111 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
00112 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
00113 # define _CRT_SECURE_NO_DEPRECATE
00114 #endif
00115 
00116 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
00117 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
00118 # define _SCL_SECURE_NO_DEPRECATE
00119 #endif
00120 
00121 
00122 
00123 /* Fix for jlong on some versions of gcc on Windows */
00124 #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
00125   typedef long long __int64;
00126 #endif
00127 
00128 /* Fix for jlong on 64-bit x86 Solaris */
00129 #if defined(__x86_64)
00130 # ifdef _LP64
00131 #   undef _LP64
00132 # endif
00133 #endif
00134 
00135 #include <jni.h>
00136 #include <stdlib.h>
00137 #include <string.h>
00138 
00139 
00140 /* Support for throwing Java exceptions */
00141 typedef enum {
00142   SWIG_JavaOutOfMemoryError = 1, 
00143   SWIG_JavaIOException, 
00144   SWIG_JavaRuntimeException, 
00145   SWIG_JavaIndexOutOfBoundsException,
00146   SWIG_JavaArithmeticException,
00147   SWIG_JavaIllegalArgumentException,
00148   SWIG_JavaNullPointerException,
00149   SWIG_JavaDirectorPureVirtual,
00150   SWIG_JavaUnknownError
00151 } SWIG_JavaExceptionCodes;
00152 
00153 typedef struct {
00154   SWIG_JavaExceptionCodes code;
00155   const char *java_exception;
00156 } SWIG_JavaExceptions_t;
00157 
00158 
00159 static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) {
00160   jclass excep;
00161   static const SWIG_JavaExceptions_t java_exceptions[] = {
00162     { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" },
00163     { SWIG_JavaIOException, "java/io/IOException" },
00164     { SWIG_JavaRuntimeException, "java/lang/RuntimeException" },
00165     { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" },
00166     { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" },
00167     { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" },
00168     { SWIG_JavaNullPointerException, "java/lang/NullPointerException" },
00169     { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" },
00170     { SWIG_JavaUnknownError,  "java/lang/UnknownError" },
00171     { (SWIG_JavaExceptionCodes)0,  "java/lang/UnknownError" }
00172   };
00173   const SWIG_JavaExceptions_t *except_ptr = java_exceptions;
00174 
00175   while (except_ptr->code != code && except_ptr->code)
00176     except_ptr++;
00177 
00178   (*jenv)->ExceptionClear(jenv);
00179   excep = (*jenv)->FindClass(jenv, except_ptr->java_exception);
00180   if (excep)
00181     (*jenv)->ThrowNew(jenv, excep, msg);
00182 }
00183 
00184 
00185 /* Contract support */
00186 
00187 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } else
00188 
00189 
00190 #include "plplotP.h"
00191 
00192 
00193     static JavaVM *cached_jvm = NULL;
00194 
00195     SWIGEXPORT JNIEXPORT jint JNICALL JNI_OnLoad( JavaVM *jvm, void *reserved )
00196     {
00197         cached_jvm = jvm;
00198         return JNI_VERSION_1_2;
00199     }
00200 
00201 
00202 //--------------------------------------------------------------------------
00203 // Array allocation & copy helper routines.  Note because of swig limitations
00204 // it is necessary to release the java array memory right after calling these
00205 // routines.  Thus it is necessary to allocate and copy the arrays  even if
00206 // the java and plplot arrays are of the same type.  Note, because of this
00207 // change to Geoffrey's original versions, caller must always free memory
00208 // afterwards.  Thus, the must_free_buffers logic is gone as well.
00209 //--------------------------------------------------------------------------
00210 
00211 // 1d array of jbooleans
00212 
00213     static void
00214     setup_array_1d_b( PLBOOL **pa, jboolean *adat, int n )
00215     {
00216         int i;
00217         *pa = (PLBOOL *) malloc( n * sizeof ( PLBOOL ) );
00218         for ( i = 0; i < n; i++ )
00219         {
00220             ( *pa )[i] = adat[i] ? 1 : 0;
00221         }
00222     }
00223 
00224 // 1d array of jints
00225 
00226     static void
00227     setup_array_1d_i( PLINT **pa, jint *adat, int n )
00228     {
00229         int i;
00230         *pa = (PLINT *) malloc( n * sizeof ( PLINT ) );
00231         for ( i = 0; i < n; i++ )
00232         {
00233             ( *pa )[i] = adat[i];
00234         }
00235     }
00236 
00237 // 1d array of jfloats
00238 
00239     static void
00240     setup_array_1d_f( PLFLT **pa, jfloat *adat, int n )
00241     {
00242         int i;
00243         *pa = (PLFLT *) malloc( n * sizeof ( PLFLT ) );
00244         for ( i = 0; i < n; i++ )
00245         {
00246             ( *pa )[i] = adat[i];
00247         }
00248     }
00249 
00250 // 1d array of jdoubles
00251 
00252     static void
00253     setup_array_1d_d( PLFLT **pa, jdouble *adat, int n )
00254     {
00255         int i;
00256         *pa = (PLFLT *) malloc( n * sizeof ( PLFLT ) );
00257         for ( i = 0; i < n; i++ )
00258         {
00259             ( *pa )[i] = adat[i];
00260         }
00261     }
00262 
00263 // 2d array of floats
00264 // Here caller must free(a[0]) and free(a) (in that order) afterward
00265 
00266     static void
00267     setup_array_2d_f( PLFLT ***pa, jfloat **adat, int nx, int ny )
00268     {
00269         int i, j;
00270 
00271         *pa        = (PLFLT **) malloc( nx * sizeof ( PLFLT * ) );
00272         ( *pa )[0] = (PLFLT *) malloc( nx * ny * sizeof ( PLFLT ) );
00273 
00274         for ( i = 0; i < nx; i++ )
00275         {
00276             ( *pa )[i] = ( *pa )[0] + i * ny;
00277             for ( j = 0; j < ny; j++ )
00278                 ( *pa )[i][j] = adat[i][j];
00279         }
00280     }
00281 
00282 // 2d array of doubles
00283 // Here caller must free(a[0]) and free(a) (in that order) afterward
00284 
00285     static void
00286     setup_array_2d_d( PLFLT ***pa, jdouble **adat, int nx, int ny )
00287     {
00288         int i, j;
00289 
00290         *pa        = (PLFLT **) malloc( nx * sizeof ( PLFLT * ) );
00291         ( *pa )[0] = (PLFLT *) malloc( nx * ny * sizeof ( PLFLT ) );
00292 
00293         for ( i = 0; i < nx; i++ )
00294         {
00295             ( *pa )[i] = ( *pa )[0] + i * ny;
00296             for ( j = 0; j < ny; j++ )
00297                 ( *pa )[i][j] = adat[i][j];
00298         }
00299     }
00300 
00301 // Setup java arrays (for callback functions)
00302 
00303 // Create a jdoubleArray and fill it from the C PLFLT array dat
00304     static jdoubleArray
00305     setup_java_array_1d_PLFLT( JNIEnv *jenv, PLFLT *dat, PLINT n )
00306     {
00307         double       *x;
00308         jdoubleArray jadat;
00309 #ifdef PL_DOUBLE
00310         x = (double *) dat;
00311 #else
00312         x = (double *) malloc( n * sizeof ( double ) );
00313         for ( i = 0; i < n; i++ )
00314         {
00315             x[i] = (double) dat[i];
00316         }
00317 #endif
00318         jadat = ( *jenv )->NewDoubleArray( jenv, n );
00319         ( *jenv )->SetDoubleArrayRegion( jenv, jadat, 0, n, x );
00320 #ifndef PL_DOUBLE
00321         free( x );
00322 #endif
00323         return jadat;
00324     }
00325 
00326 // Copy back data from jdoubleArray to C PLFLT array then release java array
00327     static void
00328     release_java_array_1d_PLFLT( JNIEnv *jenv, jdoubleArray jadat, PLFLT *dat, PLINT n )
00329     {
00330         PLINT   i;
00331         jdouble *jdata = ( *jenv )->GetDoubleArrayElements( jenv, jadat, 0 );
00332         for ( i = 0; i < n; i++ )
00333         {
00334             dat[i] = (PLFLT) jdata[i];
00335         }
00336         ( *jenv )->ReleaseDoubleArrayElements( jenv, jadat, jdata, 0 );
00337     }
00338 
00339 
00340 
00341     static PLINT Alen = 0;
00342     static PLINT Xlen = 0, Ylen = 0;
00343     static PLFLT **xg;
00344     static PLFLT **yg;
00345 
00346 
00347     typedef PLINT ( *defined_func )( PLFLT, PLFLT );
00348     typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
00349     typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
00350     typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
00351     typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
00352     typedef PLFLT ( *f2eval_func )( PLINT, PLINT, PLPointer );
00353     typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
00354 
00355 
00356     jobject   mapformClass;
00357     jmethodID mapformID;
00358     JNIEnv    *cbenvMapform;
00359 
00360     // C mapform callback function which calls the java
00361     // mapform function in a PLCallbackMapform object.
00362     void mapform_java( PLINT n, PLFLT *x, PLFLT *y )
00363     {
00364         jdoubleArray jx = setup_java_array_1d_PLFLT( cbenvMapform, x, n );
00365         jdoubleArray jy = setup_java_array_1d_PLFLT( cbenvMapform, y, n );
00366         ( *cbenvMapform )->CallVoidMethod( cbenvMapform, mapformClass, mapformID, jx, jy );
00367         release_java_array_1d_PLFLT( cbenvMapform, jx, x, n );
00368         release_java_array_1d_PLFLT( cbenvMapform, jy, y, n );
00369     }
00370 
00371 
00372     jobject labelClass    = 0;
00373     jobject labelClassRef = 0;
00374 
00375     // C label plotting callback function which calls the java
00376     // label function in a PLCallbackLabel labelClassobelID
00377 // bject.
00378     void label_java( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
00379     {
00380         jstring    javaString;
00381         const char *nativeString;
00382         jint       jaxis;
00383         jdouble    jvalue;
00384         JNIEnv     *cbenv;
00385         jmethodID  labelID = 0;
00386 
00387         jaxis  = (jint) axis;
00388         jvalue = (jdouble) value;
00389 
00390         if ( ( string == NULL ) || ( len == 0 ) )
00391         {
00392             return;
00393         }
00394 
00395         string[0] = '\0';
00396 
00397         if ( cached_jvm == NULL )
00398         {
00399             fprintf( stderr, "Error! NULL jvm\n" );
00400             return;
00401         }
00402         ( *cached_jvm )->GetEnv( cached_jvm, (void **) &cbenv, JNI_VERSION_1_2 );
00403         if ( cbenv == NULL )
00404         {
00405             fprintf( stderr, "Thread not attached\n" );
00406             if ( ( *cached_jvm )->AttachCurrentThread( cached_jvm, (void **) &cbenv, NULL ) != 0 )
00407             {
00408                 fprintf( stderr, "Error attaching to JVM\n" );
00409                 return;
00410             }
00411         }
00412         if ( labelClass == 0 )
00413         {
00414             fprintf( stderr, "Error - callback undefined\n" );
00415             return;
00416         }
00417         jclass cls = ( *cbenv )->GetObjectClass( cbenv, labelClass );
00418         if ( cls == 0 )
00419         {
00420             fprintf( stderr, "Error getting callback class\n" );
00421             return;
00422         }
00423         labelID = ( *cbenv )->GetMethodID( cbenv, cls, "label", "(ID)Ljava/lang/String;" );
00424         if ( labelID != 0 )
00425         {
00426             javaString   = (jstring) ( *cbenv )->CallObjectMethod( cbenv, labelClass, labelID, jaxis, jvalue );
00427             nativeString = ( *cbenv )->GetStringUTFChars( cbenv, javaString, 0 );
00428             strncpy( string, nativeString, len );
00429             ( *cbenv )->ReleaseStringUTFChars( cbenv, javaString, nativeString );
00430         }
00431         else
00432         {
00433             fprintf( stderr, "Java callback not found\n" );
00434             string[0] = '\0';
00435         }
00436     }
00437 
00438 
00439     jobject ctClass    = 0;
00440     jobject ctClassRef = 0;
00441 
00442     // C coordinate transform callback function which calls the java
00443     // coordinate transform function in a PLCallbackCoordTrans object.
00444     void ct_java( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
00445     {
00446         jdouble      jx, jy;
00447         jdoubleArray jxt, jyt;
00448         jdouble      *xtval;
00449         jdouble      *ytval;
00450         jobject      jdata;
00451         JNIEnv       *cbenv;
00452         jmethodID    ctID = 0;
00453 
00454         jx    = (jdouble) x;
00455         jy    = (jdouble) y;
00456         jdata = (jobject) data;
00457 
00458         if ( cached_jvm == NULL )
00459         {
00460             fprintf( stderr, "Error! NULL jvm\n" );
00461             return;
00462         }
00463         ( *cached_jvm )->GetEnv( cached_jvm, (void **) &cbenv, JNI_VERSION_1_2 );
00464         if ( cbenv == NULL )
00465         {
00466             fprintf( stderr, "Thread not attached\n" );
00467             if ( ( *cached_jvm )->AttachCurrentThread( cached_jvm, (void **) &cbenv, NULL ) != 0 )
00468             {
00469                 fprintf( stderr, "Error attaching to JVM\n" );
00470                 return;
00471             }
00472         }
00473         jxt = ( *cbenv )->NewDoubleArray( cbenv, 1 );
00474         jyt = ( *cbenv )->NewDoubleArray( cbenv, 1 );
00475         if ( ctClass == 0 )
00476         {
00477             fprintf( stderr, "Error - callback undefined\n" );
00478             return;
00479         }
00480         jclass cls = ( *cbenv )->GetObjectClass( cbenv, ctClass );
00481         if ( cls == 0 )
00482         {
00483             fprintf( stderr, "Error getting callback class\n" );
00484             return;
00485         }
00486         ctID = ( *cbenv )->GetMethodID( cbenv, cls, "coordTransform", "(DD[D[DLjava/lang/Object;)V" );
00487         if ( ctID != 0 )
00488         {
00489             ( *cbenv )->CallVoidMethod( cbenv, ctClass, ctID, jx, jy, jxt, jyt, jdata );
00490             xtval = ( *cbenv )->GetDoubleArrayElements( cbenv, jxt, JNI_FALSE );
00491             ytval = ( *cbenv )->GetDoubleArrayElements( cbenv, jyt, JNI_FALSE );
00492             *xt   = (PLFLT) xtval[0];
00493             *yt   = (PLFLT) ytval[0];
00494         }
00495         else
00496         {
00497             fprintf( stderr, "Java callback not found\n" );
00498         }
00499     }
00500 
00501 
00502 #ifdef __cplusplus
00503 extern "C" {
00504 #endif
00505 
00506 SWIGEXPORT jstring JNICALL Java_plplot_core_plplotjavacJNI_jPLFLTArray_1get(JNIEnv *jenv, jclass jcls) {
00507   jstring jresult = 0 ;
00508   char *result = 0 ;
00509   
00510   (void)jenv;
00511   (void)jcls;
00512   result = (char *) "jdoubleArray";
00513   if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result);
00514   return jresult;
00515 }
00516 
00517 
00518 SWIGEXPORT jstring JNICALL Java_plplot_core_plplotjavacJNI_jPLFLTbracket_1get(JNIEnv *jenv, jclass jcls) {
00519   jstring jresult = 0 ;
00520   char *result = 0 ;
00521   
00522   (void)jenv;
00523   (void)jcls;
00524   result = (char *) "double[]";
00525   if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result);
00526   return jresult;
00527 }
00528 
00529 
00530 SWIGEXPORT jstring JNICALL Java_plplot_core_plplotjavacJNI_jPLFLTbracket2_1get(JNIEnv *jenv, jclass jcls) {
00531   jstring jresult = 0 ;
00532   char *result = 0 ;
00533   
00534   (void)jenv;
00535   (void)jcls;
00536   result = (char *) "double[][]";
00537   if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result);
00538   return jresult;
00539 }
00540 
00541 
00542 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1SET_1RGB_1get(JNIEnv *jenv, jclass jcls) {
00543   jint jresult = 0 ;
00544   int result;
00545   
00546   (void)jenv;
00547   (void)jcls;
00548   result = (int) 1;
00549   jresult = (jint)result; 
00550   return jresult;
00551 }
00552 
00553 
00554 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1ALLOC_1NCOL_1get(JNIEnv *jenv, jclass jcls) {
00555   jint jresult = 0 ;
00556   int result;
00557   
00558   (void)jenv;
00559   (void)jcls;
00560   result = (int) 2;
00561   jresult = (jint)result; 
00562   return jresult;
00563 }
00564 
00565 
00566 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1SET_1LPB_1get(JNIEnv *jenv, jclass jcls) {
00567   jint jresult = 0 ;
00568   int result;
00569   
00570   (void)jenv;
00571   (void)jcls;
00572   result = (int) 3;
00573   jresult = (jint)result; 
00574   return jresult;
00575 }
00576 
00577 
00578 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1EXPOSE_1get(JNIEnv *jenv, jclass jcls) {
00579   jint jresult = 0 ;
00580   int result;
00581   
00582   (void)jenv;
00583   (void)jcls;
00584   result = (int) 4;
00585   jresult = (jint)result; 
00586   return jresult;
00587 }
00588 
00589 
00590 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1RESIZE_1get(JNIEnv *jenv, jclass jcls) {
00591   jint jresult = 0 ;
00592   int result;
00593   
00594   (void)jenv;
00595   (void)jcls;
00596   result = (int) 5;
00597   jresult = (jint)result; 
00598   return jresult;
00599 }
00600 
00601 
00602 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1REDRAW_1get(JNIEnv *jenv, jclass jcls) {
00603   jint jresult = 0 ;
00604   int result;
00605   
00606   (void)jenv;
00607   (void)jcls;
00608   result = (int) 6;
00609   jresult = (jint)result; 
00610   return jresult;
00611 }
00612 
00613 
00614 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1TEXT_1get(JNIEnv *jenv, jclass jcls) {
00615   jint jresult = 0 ;
00616   int result;
00617   
00618   (void)jenv;
00619   (void)jcls;
00620   result = (int) 7;
00621   jresult = (jint)result; 
00622   return jresult;
00623 }
00624 
00625 
00626 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1GRAPH_1get(JNIEnv *jenv, jclass jcls) {
00627   jint jresult = 0 ;
00628   int result;
00629   
00630   (void)jenv;
00631   (void)jcls;
00632   result = (int) 8;
00633   jresult = (jint)result; 
00634   return jresult;
00635 }
00636 
00637 
00638 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1FILL_1get(JNIEnv *jenv, jclass jcls) {
00639   jint jresult = 0 ;
00640   int result;
00641   
00642   (void)jenv;
00643   (void)jcls;
00644   result = (int) 9;
00645   jresult = (jint)result; 
00646   return jresult;
00647 }
00648 
00649 
00650 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1DI_1get(JNIEnv *jenv, jclass jcls) {
00651   jint jresult = 0 ;
00652   int result;
00653   
00654   (void)jenv;
00655   (void)jcls;
00656   result = (int) 10;
00657   jresult = (jint)result; 
00658   return jresult;
00659 }
00660 
00661 
00662 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1FLUSH_1get(JNIEnv *jenv, jclass jcls) {
00663   jint jresult = 0 ;
00664   int result;
00665   
00666   (void)jenv;
00667   (void)jcls;
00668   result = (int) 11;
00669   jresult = (jint)result; 
00670   return jresult;
00671 }
00672 
00673 
00674 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1EH_1get(JNIEnv *jenv, jclass jcls) {
00675   jint jresult = 0 ;
00676   int result;
00677   
00678   (void)jenv;
00679   (void)jcls;
00680   result = (int) 12;
00681   jresult = (jint)result; 
00682   return jresult;
00683 }
00684 
00685 
00686 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1GETC_1get(JNIEnv *jenv, jclass jcls) {
00687   jint jresult = 0 ;
00688   int result;
00689   
00690   (void)jenv;
00691   (void)jcls;
00692   result = (int) 13;
00693   jresult = (jint)result; 
00694   return jresult;
00695 }
00696 
00697 
00698 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1SWIN_1get(JNIEnv *jenv, jclass jcls) {
00699   jint jresult = 0 ;
00700   int result;
00701   
00702   (void)jenv;
00703   (void)jcls;
00704   result = (int) 14;
00705   jresult = (jint)result; 
00706   return jresult;
00707 }
00708 
00709 
00710 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1PLFLTBUFFERING_1get(JNIEnv *jenv, jclass jcls) {
00711   jint jresult = 0 ;
00712   int result;
00713   
00714   (void)jenv;
00715   (void)jcls;
00716   result = (int) 15;
00717   jresult = (jint)result; 
00718   return jresult;
00719 }
00720 
00721 
00722 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1XORMOD_1get(JNIEnv *jenv, jclass jcls) {
00723   jint jresult = 0 ;
00724   int result;
00725   
00726   (void)jenv;
00727   (void)jcls;
00728   result = (int) 16;
00729   jresult = (jint)result; 
00730   return jresult;
00731 }
00732 
00733 
00734 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1SET_1COMPRESSION_1get(JNIEnv *jenv, jclass jcls) {
00735   jint jresult = 0 ;
00736   int result;
00737   
00738   (void)jenv;
00739   (void)jcls;
00740   result = (int) 17;
00741   jresult = (jint)result; 
00742   return jresult;
00743 }
00744 
00745 
00746 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1CLEAR_1get(JNIEnv *jenv, jclass jcls) {
00747   jint jresult = 0 ;
00748   int result;
00749   
00750   (void)jenv;
00751   (void)jcls;
00752   result = (int) 18;
00753   jresult = (jint)result; 
00754   return jresult;
00755 }
00756 
00757 
00758 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1DASH_1get(JNIEnv *jenv, jclass jcls) {
00759   jint jresult = 0 ;
00760   int result;
00761   
00762   (void)jenv;
00763   (void)jcls;
00764   result = (int) 19;
00765   jresult = (jint)result; 
00766   return jresult;
00767 }
00768 
00769 
00770 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1HAS_1TEXT_1get(JNIEnv *jenv, jclass jcls) {
00771   jint jresult = 0 ;
00772   int result;
00773   
00774   (void)jenv;
00775   (void)jcls;
00776   result = (int) 20;
00777   jresult = (jint)result; 
00778   return jresult;
00779 }
00780 
00781 
00782 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1IMAGE_1get(JNIEnv *jenv, jclass jcls) {
00783   jint jresult = 0 ;
00784   int result;
00785   
00786   (void)jenv;
00787   (void)jcls;
00788   result = (int) 21;
00789   jresult = (jint)result; 
00790   return jresult;
00791 }
00792 
00793 
00794 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1IMAGEOPS_1get(JNIEnv *jenv, jclass jcls) {
00795   jint jresult = 0 ;
00796   int result;
00797   
00798   (void)jenv;
00799   (void)jcls;
00800   result = (int) 22;
00801   jresult = (jint)result; 
00802   return jresult;
00803 }
00804 
00805 
00806 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_DRAW_1LINEX_1get(JNIEnv *jenv, jclass jcls) {
00807   jint jresult = 0 ;
00808   int result;
00809   
00810   (void)jenv;
00811   (void)jcls;
00812   result = (int) 0x01;
00813   jresult = (jint)result; 
00814   return jresult;
00815 }
00816 
00817 
00818 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_DRAW_1LINEY_1get(JNIEnv *jenv, jclass jcls) {
00819   jint jresult = 0 ;
00820   int result;
00821   
00822   (void)jenv;
00823   (void)jcls;
00824   result = (int) 0x02;
00825   jresult = (jint)result; 
00826   return jresult;
00827 }
00828 
00829 
00830 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_DRAW_1LINEXY_1get(JNIEnv *jenv, jclass jcls) {
00831   jint jresult = 0 ;
00832   int result;
00833   
00834   (void)jenv;
00835   (void)jcls;
00836   result = (int) 0x03;
00837   jresult = (jint)result; 
00838   return jresult;
00839 }
00840 
00841 
00842 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_MAG_1COLOR_1get(JNIEnv *jenv, jclass jcls) {
00843   jint jresult = 0 ;
00844   int result;
00845   
00846   (void)jenv;
00847   (void)jcls;
00848   result = (int) 0x04;
00849   jresult = (jint)result; 
00850   return jresult;
00851 }
00852 
00853 
00854 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_BASE_1CONT_1get(JNIEnv *jenv, jclass jcls) {
00855   jint jresult = 0 ;
00856   int result;
00857   
00858   (void)jenv;
00859   (void)jcls;
00860   result = (int) 0x08;
00861   jresult = (jint)result; 
00862   return jresult;
00863 }
00864 
00865 
00866 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_TOP_1CONT_1get(JNIEnv *jenv, jclass jcls) {
00867   jint jresult = 0 ;
00868   int result;
00869   
00870   (void)jenv;
00871   (void)jcls;
00872   result = (int) 0x10;
00873   jresult = (jint)result; 
00874   return jresult;
00875 }
00876 
00877 
00878 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_SURF_1CONT_1get(JNIEnv *jenv, jclass jcls) {
00879   jint jresult = 0 ;
00880   int result;
00881   
00882   (void)jenv;
00883   (void)jcls;
00884   result = (int) 0x20;
00885   jresult = (jint)result; 
00886   return jresult;
00887 }
00888 
00889 
00890 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_DRAW_1SIDES_1get(JNIEnv *jenv, jclass jcls) {
00891   jint jresult = 0 ;
00892   int result;
00893   
00894   (void)jenv;
00895   (void)jcls;
00896   result = (int) 0x40;
00897   jresult = (jint)result; 
00898   return jresult;
00899 }
00900 
00901 
00902 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_FACETED_1get(JNIEnv *jenv, jclass jcls) {
00903   jint jresult = 0 ;
00904   int result;
00905   
00906   (void)jenv;
00907   (void)jcls;
00908   result = (int) 0x80;
00909   jresult = (jint)result; 
00910   return jresult;
00911 }
00912 
00913 
00914 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_MESH_1get(JNIEnv *jenv, jclass jcls) {
00915   jint jresult = 0 ;
00916   int result;
00917   
00918   (void)jenv;
00919   (void)jcls;
00920   result = (int) 0x100;
00921   jresult = (jint)result; 
00922   return jresult;
00923 }
00924 
00925 
00926 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1BIN_1DEFAULT_1get(JNIEnv *jenv, jclass jcls) {
00927   jint jresult = 0 ;
00928   int result;
00929   
00930   (void)jenv;
00931   (void)jcls;
00932   result = (int) 0;
00933   jresult = (jint)result; 
00934   return jresult;
00935 }
00936 
00937 
00938 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1BIN_1CENTRED_1get(JNIEnv *jenv, jclass jcls) {
00939   jint jresult = 0 ;
00940   int result;
00941   
00942   (void)jenv;
00943   (void)jcls;
00944   result = (int) 1;
00945   jresult = (jint)result; 
00946   return jresult;
00947 }
00948 
00949 
00950 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1BIN_1NOEXPAND_1get(JNIEnv *jenv, jclass jcls) {
00951   jint jresult = 0 ;
00952   int result;
00953   
00954   (void)jenv;
00955   (void)jcls;
00956   result = (int) 2;
00957   jresult = (jint)result; 
00958   return jresult;
00959 }
00960 
00961 
00962 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1BIN_1NOEMPTY_1get(JNIEnv *jenv, jclass jcls) {
00963   jint jresult = 0 ;
00964   int result;
00965   
00966   (void)jenv;
00967   (void)jcls;
00968   result = (int) 4;
00969   jresult = (jint)result; 
00970   return jresult;
00971 }
00972 
00973 
00974 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1HIST_1DEFAULT_1get(JNIEnv *jenv, jclass jcls) {
00975   jint jresult = 0 ;
00976   int result;
00977   
00978   (void)jenv;
00979   (void)jcls;
00980   result = (int) 0;
00981   jresult = (jint)result; 
00982   return jresult;
00983 }
00984 
00985 
00986 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1HIST_1NOSCALING_1get(JNIEnv *jenv, jclass jcls) {
00987   jint jresult = 0 ;
00988   int result;
00989   
00990   (void)jenv;
00991   (void)jcls;
00992   result = (int) 1;
00993   jresult = (jint)result; 
00994   return jresult;
00995 }
00996 
00997 
00998 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1HIST_1IGNORE_1OUTLIERS_1get(JNIEnv *jenv, jclass jcls) {
00999   jint jresult = 0 ;
01000   int result;
01001   
01002   (void)jenv;
01003   (void)jcls;
01004   result = (int) 2;
01005   jresult = (jint)result; 
01006   return jresult;
01007 }
01008 
01009 
01010 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1HIST_1NOEXPAND_1get(JNIEnv *jenv, jclass jcls) {
01011   jint jresult = 0 ;
01012   int result;
01013   
01014   (void)jenv;
01015   (void)jcls;
01016   result = (int) 8;
01017   jresult = (jint)result; 
01018   return jresult;
01019 }
01020 
01021 
01022 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1HIST_1NOEMPTY_1get(JNIEnv *jenv, jclass jcls) {
01023   jint jresult = 0 ;
01024   int result;
01025   
01026   (void)jenv;
01027   (void)jcls;
01028   result = (int) 16;
01029   jresult = (jint)result; 
01030   return jresult;
01031 }
01032 
01033 
01034 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1POSITION_1LEFT_1get(JNIEnv *jenv, jclass jcls) {
01035   jint jresult = 0 ;
01036   int result;
01037   
01038   (void)jenv;
01039   (void)jcls;
01040   result = (int) 1;
01041   jresult = (jint)result; 
01042   return jresult;
01043 }
01044 
01045 
01046 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1POSITION_1RIGHT_1get(JNIEnv *jenv, jclass jcls) {
01047   jint jresult = 0 ;
01048   int result;
01049   
01050   (void)jenv;
01051   (void)jcls;
01052   result = (int) 2;
01053   jresult = (jint)result; 
01054   return jresult;
01055 }
01056 
01057 
01058 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1POSITION_1TOP_1get(JNIEnv *jenv, jclass jcls) {
01059   jint jresult = 0 ;
01060   int result;
01061   
01062   (void)jenv;
01063   (void)jcls;
01064   result = (int) 4;
01065   jresult = (jint)result; 
01066   return jresult;
01067 }
01068 
01069 
01070 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1POSITION_1BOTTOM_1get(JNIEnv *jenv, jclass jcls) {
01071   jint jresult = 0 ;
01072   int result;
01073   
01074   (void)jenv;
01075   (void)jcls;
01076   result = (int) 8;
01077   jresult = (jint)result; 
01078   return jresult;
01079 }
01080 
01081 
01082 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1POSITION_1INSIDE_1get(JNIEnv *jenv, jclass jcls) {
01083   jint jresult = 0 ;
01084   int result;
01085   
01086   (void)jenv;
01087   (void)jcls;
01088   result = (int) 16;
01089   jresult = (jint)result; 
01090   return jresult;
01091 }
01092 
01093 
01094 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1POSITION_1OUTSIDE_1get(JNIEnv *jenv, jclass jcls) {
01095   jint jresult = 0 ;
01096   int result;
01097   
01098   (void)jenv;
01099   (void)jcls;
01100   result = (int) 32;
01101   jresult = (jint)result; 
01102   return jresult;
01103 }
01104 
01105 
01106 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1POSITION_1VIEWPORT_1get(JNIEnv *jenv, jclass jcls) {
01107   jint jresult = 0 ;
01108   int result;
01109   
01110   (void)jenv;
01111   (void)jcls;
01112   result = (int) 64;
01113   jresult = (jint)result; 
01114   return jresult;
01115 }
01116 
01117 
01118 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1POSITION_1SUBPAGE_1get(JNIEnv *jenv, jclass jcls) {
01119   jint jresult = 0 ;
01120   int result;
01121   
01122   (void)jenv;
01123   (void)jcls;
01124   result = (int) 128;
01125   jresult = (jint)result; 
01126   return jresult;
01127 }
01128 
01129 
01130 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1LEGEND_1NONE_1get(JNIEnv *jenv, jclass jcls) {
01131   jint jresult = 0 ;
01132   int result;
01133   
01134   (void)jenv;
01135   (void)jcls;
01136   result = (int) 1;
01137   jresult = (jint)result; 
01138   return jresult;
01139 }
01140 
01141 
01142 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1LEGEND_1COLOR_1BOX_1get(JNIEnv *jenv, jclass jcls) {
01143   jint jresult = 0 ;
01144   int result;
01145   
01146   (void)jenv;
01147   (void)jcls;
01148   result = (int) 2;
01149   jresult = (jint)result; 
01150   return jresult;
01151 }
01152 
01153 
01154 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1LEGEND_1LINE_1get(JNIEnv *jenv, jclass jcls) {
01155   jint jresult = 0 ;
01156   int result;
01157   
01158   (void)jenv;
01159   (void)jcls;
01160   result = (int) 4;
01161   jresult = (jint)result; 
01162   return jresult;
01163 }
01164 
01165 
01166 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1LEGEND_1SYMBOL_1get(JNIEnv *jenv, jclass jcls) {
01167   jint jresult = 0 ;
01168   int result;
01169   
01170   (void)jenv;
01171   (void)jcls;
01172   result = (int) 8;
01173   jresult = (jint)result; 
01174   return jresult;
01175 }
01176 
01177 
01178 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1LEGEND_1TEXT_1LEFT_1get(JNIEnv *jenv, jclass jcls) {
01179   jint jresult = 0 ;
01180   int result;
01181   
01182   (void)jenv;
01183   (void)jcls;
01184   result = (int) 16;
01185   jresult = (jint)result; 
01186   return jresult;
01187 }
01188 
01189 
01190 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1LEGEND_1BACKGROUND_1get(JNIEnv *jenv, jclass jcls) {
01191   jint jresult = 0 ;
01192   int result;
01193   
01194   (void)jenv;
01195   (void)jcls;
01196   result = (int) 32;
01197   jresult = (jint)result; 
01198   return jresult;
01199 }
01200 
01201 
01202 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1LEGEND_1BOUNDING_1BOX_1get(JNIEnv *jenv, jclass jcls) {
01203   jint jresult = 0 ;
01204   int result;
01205   
01206   (void)jenv;
01207   (void)jcls;
01208   result = (int) 64;
01209   jresult = (jint)result; 
01210   return jresult;
01211 }
01212 
01213 
01214 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1LEGEND_1ROW_1MAJOR_1get(JNIEnv *jenv, jclass jcls) {
01215   jint jresult = 0 ;
01216   int result;
01217   
01218   (void)jenv;
01219   (void)jcls;
01220   result = (int) 128;
01221   jresult = (jint)result; 
01222   return jresult;
01223 }
01224 
01225 
01226 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1LABEL_1LEFT_1get(JNIEnv *jenv, jclass jcls) {
01227   jint jresult = 0 ;
01228   int result;
01229   
01230   (void)jenv;
01231   (void)jcls;
01232   result = (int) 1;
01233   jresult = (jint)result; 
01234   return jresult;
01235 }
01236 
01237 
01238 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1LABEL_1RIGHT_1get(JNIEnv *jenv, jclass jcls) {
01239   jint jresult = 0 ;
01240   int result;
01241   
01242   (void)jenv;
01243   (void)jcls;
01244   result = (int) 2;
01245   jresult = (jint)result; 
01246   return jresult;
01247 }
01248 
01249 
01250 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1LABEL_1TOP_1get(JNIEnv *jenv, jclass jcls) {
01251   jint jresult = 0 ;
01252   int result;
01253   
01254   (void)jenv;
01255   (void)jcls;
01256   result = (int) 4;
01257   jresult = (jint)result; 
01258   return jresult;
01259 }
01260 
01261 
01262 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1LABEL_1BOTTOM_1get(JNIEnv *jenv, jclass jcls) {
01263   jint jresult = 0 ;
01264   int result;
01265   
01266   (void)jenv;
01267   (void)jcls;
01268   result = (int) 8;
01269   jresult = (jint)result; 
01270   return jresult;
01271 }
01272 
01273 
01274 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1IMAGE_1get(JNIEnv *jenv, jclass jcls) {
01275   jint jresult = 0 ;
01276   int result;
01277   
01278   (void)jenv;
01279   (void)jcls;
01280   result = (int) 16;
01281   jresult = (jint)result; 
01282   return jresult;
01283 }
01284 
01285 
01286 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1SHADE_1get(JNIEnv *jenv, jclass jcls) {
01287   jint jresult = 0 ;
01288   int result;
01289   
01290   (void)jenv;
01291   (void)jcls;
01292   result = (int) 32;
01293   jresult = (jint)result; 
01294   return jresult;
01295 }
01296 
01297 
01298 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1GRADIENT_1get(JNIEnv *jenv, jclass jcls) {
01299   jint jresult = 0 ;
01300   int result;
01301   
01302   (void)jenv;
01303   (void)jcls;
01304   result = (int) 64;
01305   jresult = (jint)result; 
01306   return jresult;
01307 }
01308 
01309 
01310 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1CAP_1LOW_1get(JNIEnv *jenv, jclass jcls) {
01311   jint jresult = 0 ;
01312   int result;
01313   
01314   (void)jenv;
01315   (void)jcls;
01316   result = (int) 128;
01317   jresult = (jint)result; 
01318   return jresult;
01319 }
01320 
01321 
01322 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1CAP_1HIGH_1get(JNIEnv *jenv, jclass jcls) {
01323   jint jresult = 0 ;
01324   int result;
01325   
01326   (void)jenv;
01327   (void)jcls;
01328   result = (int) 256;
01329   jresult = (jint)result; 
01330   return jresult;
01331 }
01332 
01333 
01334 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1SHADE_1LABEL_1get(JNIEnv *jenv, jclass jcls) {
01335   jint jresult = 0 ;
01336   int result;
01337   
01338   (void)jenv;
01339   (void)jcls;
01340   result = (int) 512;
01341   jresult = (jint)result; 
01342   return jresult;
01343 }
01344 
01345 
01346 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLSWIN_1DEVICE_1get(JNIEnv *jenv, jclass jcls) {
01347   jint jresult = 0 ;
01348   int result;
01349   
01350   (void)jenv;
01351   (void)jcls;
01352   result = (int) 1;
01353   jresult = (jint)result; 
01354   return jresult;
01355 }
01356 
01357 
01358 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLSWIN_1WORLD_1get(JNIEnv *jenv, jclass jcls) {
01359   jint jresult = 0 ;
01360   int result;
01361   
01362   (void)jenv;
01363   (void)jcls;
01364   result = (int) 2;
01365   jresult = (jint)result; 
01366   return jresult;
01367 }
01368 
01369 
01370 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1X_1AXIS_1get(JNIEnv *jenv, jclass jcls) {
01371   jint jresult = 0 ;
01372   int result;
01373   
01374   (void)jenv;
01375   (void)jcls;
01376   result = (int) 1;
01377   jresult = (jint)result; 
01378   return jresult;
01379 }
01380 
01381 
01382 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1Y_1AXIS_1get(JNIEnv *jenv, jclass jcls) {
01383   jint jresult = 0 ;
01384   int result;
01385   
01386   (void)jenv;
01387   (void)jcls;
01388   result = (int) 2;
01389   jresult = (jint)result; 
01390   return jresult;
01391 }
01392 
01393 
01394 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1Z_1AXIS_1get(JNIEnv *jenv, jclass jcls) {
01395   jint jresult = 0 ;
01396   int result;
01397   
01398   (void)jenv;
01399   (void)jcls;
01400   result = (int) 3;
01401   jresult = (jint)result; 
01402   return jresult;
01403 }
01404 
01405 
01406 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1OPT_1ENABLED_1get(JNIEnv *jenv, jclass jcls) {
01407   jint jresult = 0 ;
01408   int result;
01409   
01410   (void)jenv;
01411   (void)jcls;
01412   result = (int) 0x0001;
01413   jresult = (jint)result; 
01414   return jresult;
01415 }
01416 
01417 
01418 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1OPT_1ARG_1get(JNIEnv *jenv, jclass jcls) {
01419   jint jresult = 0 ;
01420   int result;
01421   
01422   (void)jenv;
01423   (void)jcls;
01424   result = (int) 0x0002;
01425   jresult = (jint)result; 
01426   return jresult;
01427 }
01428 
01429 
01430 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1OPT_1NODELETE_1get(JNIEnv *jenv, jclass jcls) {
01431   jint jresult = 0 ;
01432   int result;
01433   
01434   (void)jenv;
01435   (void)jcls;
01436   result = (int) 0x0004;
01437   jresult = (jint)result; 
01438   return jresult;
01439 }
01440 
01441 
01442 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1OPT_1INVISIBLE_1get(JNIEnv *jenv, jclass jcls) {
01443   jint jresult = 0 ;
01444   int result;
01445   
01446   (void)jenv;
01447   (void)jcls;
01448   result = (int) 0x0008;
01449   jresult = (jint)result; 
01450   return jresult;
01451 }
01452 
01453 
01454 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1OPT_1DISABLED_1get(JNIEnv *jenv, jclass jcls) {
01455   jint jresult = 0 ;
01456   int result;
01457   
01458   (void)jenv;
01459   (void)jcls;
01460   result = (int) 0x0010;
01461   jresult = (jint)result; 
01462   return jresult;
01463 }
01464 
01465 
01466 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1OPT_1FUNC_1get(JNIEnv *jenv, jclass jcls) {
01467   jint jresult = 0 ;
01468   int result;
01469   
01470   (void)jenv;
01471   (void)jcls;
01472   result = (int) 0x0100;
01473   jresult = (jint)result; 
01474   return jresult;
01475 }
01476 
01477 
01478 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1OPT_1BOOL_1get(JNIEnv *jenv, jclass jcls) {
01479   jint jresult = 0 ;
01480   int result;
01481   
01482   (void)jenv;
01483   (void)jcls;
01484   result = (int) 0x0200;
01485   jresult = (jint)result; 
01486   return jresult;
01487 }
01488 
01489 
01490 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1OPT_1INT_1get(JNIEnv *jenv, jclass jcls) {
01491   jint jresult = 0 ;
01492   int result;
01493   
01494   (void)jenv;
01495   (void)jcls;
01496   result = (int) 0x0400;
01497   jresult = (jint)result; 
01498   return jresult;
01499 }
01500 
01501 
01502 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1OPT_1FLOAT_1get(JNIEnv *jenv, jclass jcls) {
01503   jint jresult = 0 ;
01504   int result;
01505   
01506   (void)jenv;
01507   (void)jcls;
01508   result = (int) 0x0800;
01509   jresult = (jint)result; 
01510   return jresult;
01511 }
01512 
01513 
01514 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1OPT_1STRING_1get(JNIEnv *jenv, jclass jcls) {
01515   jint jresult = 0 ;
01516   int result;
01517   
01518   (void)jenv;
01519   (void)jcls;
01520   result = (int) 0x1000;
01521   jresult = (jint)result; 
01522   return jresult;
01523 }
01524 
01525 
01526 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1PARSE_1PARTIAL_1get(JNIEnv *jenv, jclass jcls) {
01527   jint jresult = 0 ;
01528   int result;
01529   
01530   (void)jenv;
01531   (void)jcls;
01532   result = (int) 0x0000;
01533   jresult = (jint)result; 
01534   return jresult;
01535 }
01536 
01537 
01538 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1PARSE_1FULL_1get(JNIEnv *jenv, jclass jcls) {
01539   jint jresult = 0 ;
01540   int result;
01541   
01542   (void)jenv;
01543   (void)jcls;
01544   result = (int) 0x0001;
01545   jresult = (jint)result; 
01546   return jresult;
01547 }
01548 
01549 
01550 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1PARSE_1QUIET_1get(JNIEnv *jenv, jclass jcls) {
01551   jint jresult = 0 ;
01552   int result;
01553   
01554   (void)jenv;
01555   (void)jcls;
01556   result = (int) 0x0002;
01557   jresult = (jint)result; 
01558   return jresult;
01559 }
01560 
01561 
01562 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1PARSE_1NODELETE_1get(JNIEnv *jenv, jclass jcls) {
01563   jint jresult = 0 ;
01564   int result;
01565   
01566   (void)jenv;
01567   (void)jcls;
01568   result = (int) 0x0004;
01569   jresult = (jint)result; 
01570   return jresult;
01571 }
01572 
01573 
01574 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1PARSE_1SHOWALL_1get(JNIEnv *jenv, jclass jcls) {
01575   jint jresult = 0 ;
01576   int result;
01577   
01578   (void)jenv;
01579   (void)jcls;
01580   result = (int) 0x0008;
01581   jresult = (jint)result; 
01582   return jresult;
01583 }
01584 
01585 
01586 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1PARSE_1OVERRIDE_1get(JNIEnv *jenv, jclass jcls) {
01587   jint jresult = 0 ;
01588   int result;
01589   
01590   (void)jenv;
01591   (void)jcls;
01592   result = (int) 0x0010;
01593   jresult = (jint)result; 
01594   return jresult;
01595 }
01596 
01597 
01598 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1PARSE_1NOPROGRAM_1get(JNIEnv *jenv, jclass jcls) {
01599   jint jresult = 0 ;
01600   int result;
01601   
01602   (void)jenv;
01603   (void)jcls;
01604   result = (int) 0x0020;
01605   jresult = (jint)result; 
01606   return jresult;
01607 }
01608 
01609 
01610 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1PARSE_1NODASH_1get(JNIEnv *jenv, jclass jcls) {
01611   jint jresult = 0 ;
01612   int result;
01613   
01614   (void)jenv;
01615   (void)jcls;
01616   result = (int) 0x0040;
01617   jresult = (jint)result; 
01618   return jresult;
01619 }
01620 
01621 
01622 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1PARSE_1SKIP_1get(JNIEnv *jenv, jclass jcls) {
01623   jint jresult = 0 ;
01624   int result;
01625   
01626   (void)jenv;
01627   (void)jcls;
01628   result = (int) 0x0080;
01629   jresult = (jint)result; 
01630   return jresult;
01631 }
01632 
01633 
01634 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1MARK_1get(JNIEnv *jenv, jclass jcls) {
01635   jint jresult = 0 ;
01636   int result;
01637   
01638   (void)jenv;
01639   (void)jcls;
01640   result = (int) 0x80000000;
01641   jresult = (jint)result; 
01642   return jresult;
01643 }
01644 
01645 
01646 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1IMPOSSIBLE_1get(JNIEnv *jenv, jclass jcls) {
01647   jint jresult = 0 ;
01648   int result;
01649   
01650   (void)jenv;
01651   (void)jcls;
01652   result = (int) 0x00000000;
01653   jresult = (jint)result; 
01654   return jresult;
01655 }
01656 
01657 
01658 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1HEXDIGIT_1MASK_1get(JNIEnv *jenv, jclass jcls) {
01659   jint jresult = 0 ;
01660   int result;
01661   
01662   (void)jenv;
01663   (void)jcls;
01664   result = (int) 0xf;
01665   jresult = (jint)result; 
01666   return jresult;
01667 }
01668 
01669 
01670 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1HEXPOWER_1MASK_1get(JNIEnv *jenv, jclass jcls) {
01671   jint jresult = 0 ;
01672   int result;
01673   
01674   (void)jenv;
01675   (void)jcls;
01676   result = (int) 0x7;
01677   jresult = (jint)result; 
01678   return jresult;
01679 }
01680 
01681 
01682 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1HEXPOWER_1IMPOSSIBLE_1get(JNIEnv *jenv, jclass jcls) {
01683   jint jresult = 0 ;
01684   int result;
01685   
01686   (void)jenv;
01687   (void)jcls;
01688   result = (int) 0xf;
01689   jresult = (jint)result; 
01690   return jresult;
01691 }
01692 
01693 
01694 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1FAMILY_1get(JNIEnv *jenv, jclass jcls) {
01695   jint jresult = 0 ;
01696   int result;
01697   
01698   (void)jenv;
01699   (void)jcls;
01700   result = (int) 0x0;
01701   jresult = (jint)result; 
01702   return jresult;
01703 }
01704 
01705 
01706 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1STYLE_1get(JNIEnv *jenv, jclass jcls) {
01707   jint jresult = 0 ;
01708   int result;
01709   
01710   (void)jenv;
01711   (void)jcls;
01712   result = (int) 0x1;
01713   jresult = (jint)result; 
01714   return jresult;
01715 }
01716 
01717 
01718 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1WEIGHT_1get(JNIEnv *jenv, jclass jcls) {
01719   jint jresult = 0 ;
01720   int result;
01721   
01722   (void)jenv;
01723   (void)jcls;
01724   result = (int) 0x2;
01725   jresult = (jint)result; 
01726   return jresult;
01727 }
01728 
01729 
01730 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1SANS_1get(JNIEnv *jenv, jclass jcls) {
01731   jint jresult = 0 ;
01732   int result;
01733   
01734   (void)jenv;
01735   (void)jcls;
01736   result = (int) 0x0;
01737   jresult = (jint)result; 
01738   return jresult;
01739 }
01740 
01741 
01742 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1SERIF_1get(JNIEnv *jenv, jclass jcls) {
01743   jint jresult = 0 ;
01744   int result;
01745   
01746   (void)jenv;
01747   (void)jcls;
01748   result = (int) 0x1;
01749   jresult = (jint)result; 
01750   return jresult;
01751 }
01752 
01753 
01754 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1MONO_1get(JNIEnv *jenv, jclass jcls) {
01755   jint jresult = 0 ;
01756   int result;
01757   
01758   (void)jenv;
01759   (void)jcls;
01760   result = (int) 0x2;
01761   jresult = (jint)result; 
01762   return jresult;
01763 }
01764 
01765 
01766 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1SCRIPT_1get(JNIEnv *jenv, jclass jcls) {
01767   jint jresult = 0 ;
01768   int result;
01769   
01770   (void)jenv;
01771   (void)jcls;
01772   result = (int) 0x3;
01773   jresult = (jint)result; 
01774   return jresult;
01775 }
01776 
01777 
01778 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1SYMBOL_1get(JNIEnv *jenv, jclass jcls) {
01779   jint jresult = 0 ;
01780   int result;
01781   
01782   (void)jenv;
01783   (void)jcls;
01784   result = (int) 0x4;
01785   jresult = (jint)result; 
01786   return jresult;
01787 }
01788 
01789 
01790 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1UPRIGHT_1get(JNIEnv *jenv, jclass jcls) {
01791   jint jresult = 0 ;
01792   int result;
01793   
01794   (void)jenv;
01795   (void)jcls;
01796   result = (int) 0x0;
01797   jresult = (jint)result; 
01798   return jresult;
01799 }
01800 
01801 
01802 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1ITALIC_1get(JNIEnv *jenv, jclass jcls) {
01803   jint jresult = 0 ;
01804   int result;
01805   
01806   (void)jenv;
01807   (void)jcls;
01808   result = (int) 0x1;
01809   jresult = (jint)result; 
01810   return jresult;
01811 }
01812 
01813 
01814 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1OBLIQUE_1get(JNIEnv *jenv, jclass jcls) {
01815   jint jresult = 0 ;
01816   int result;
01817   
01818   (void)jenv;
01819   (void)jcls;
01820   result = (int) 0x2;
01821   jresult = (jint)result; 
01822   return jresult;
01823 }
01824 
01825 
01826 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1MEDIUM_1get(JNIEnv *jenv, jclass jcls) {
01827   jint jresult = 0 ;
01828   int result;
01829   
01830   (void)jenv;
01831   (void)jcls;
01832   result = (int) 0x0;
01833   jresult = (jint)result; 
01834   return jresult;
01835 }
01836 
01837 
01838 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1BOLD_1get(JNIEnv *jenv, jclass jcls) {
01839   jint jresult = 0 ;
01840   int result;
01841   
01842   (void)jenv;
01843   (void)jcls;
01844   result = (int) 0x1;
01845   jresult = (jint)result; 
01846   return jresult;
01847 }
01848 
01849 
01850 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1MAXKEY_1get(JNIEnv *jenv, jclass jcls) {
01851   jint jresult = 0 ;
01852   int result;
01853   
01854   (void)jenv;
01855   (void)jcls;
01856   result = (int) 16;
01857   jresult = (jint)result; 
01858   return jresult;
01859 }
01860 
01861 
01862 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1type_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) {
01863   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
01864   int arg2 ;
01865   
01866   (void)jenv;
01867   (void)jcls;
01868   arg1 = *(PLGraphicsIn **)&jarg1; 
01869   arg2 = (int)jarg2; 
01870   if (arg1) (arg1)->type = arg2;
01871 }
01872 
01873 
01874 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1type_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
01875   jint jresult = 0 ;
01876   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
01877   int result;
01878   
01879   (void)jenv;
01880   (void)jcls;
01881   arg1 = *(PLGraphicsIn **)&jarg1; 
01882   result = (int) ((arg1)->type);
01883   jresult = (jint)result; 
01884   return jresult;
01885 }
01886 
01887 
01888 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1state_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) {
01889   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
01890   unsigned int arg2 ;
01891   
01892   (void)jenv;
01893   (void)jcls;
01894   arg1 = *(PLGraphicsIn **)&jarg1; 
01895   arg2 = (unsigned int)jarg2; 
01896   if (arg1) (arg1)->state = arg2;
01897 }
01898 
01899 
01900 SWIGEXPORT jlong JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1state_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
01901   jlong jresult = 0 ;
01902   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
01903   unsigned int result;
01904   
01905   (void)jenv;
01906   (void)jcls;
01907   arg1 = *(PLGraphicsIn **)&jarg1; 
01908   result = (unsigned int) ((arg1)->state);
01909   jresult = (jlong)result; 
01910   return jresult;
01911 }
01912 
01913 
01914 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1keysym_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) {
01915   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
01916   unsigned int arg2 ;
01917   
01918   (void)jenv;
01919   (void)jcls;
01920   arg1 = *(PLGraphicsIn **)&jarg1; 
01921   arg2 = (unsigned int)jarg2; 
01922   if (arg1) (arg1)->keysym = arg2;
01923 }
01924 
01925 
01926 SWIGEXPORT jlong JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1keysym_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
01927   jlong jresult = 0 ;
01928   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
01929   unsigned int result;
01930   
01931   (void)jenv;
01932   (void)jcls;
01933   arg1 = *(PLGraphicsIn **)&jarg1; 
01934   result = (unsigned int) ((arg1)->keysym);
01935   jresult = (jlong)result; 
01936   return jresult;
01937 }
01938 
01939 
01940 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1button_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) {
01941   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
01942   unsigned int arg2 ;
01943   
01944   (void)jenv;
01945   (void)jcls;
01946   arg1 = *(PLGraphicsIn **)&jarg1; 
01947   arg2 = (unsigned int)jarg2; 
01948   if (arg1) (arg1)->button = arg2;
01949 }
01950 
01951 
01952 SWIGEXPORT jlong JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1button_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
01953   jlong jresult = 0 ;
01954   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
01955   unsigned int result;
01956   
01957   (void)jenv;
01958   (void)jcls;
01959   arg1 = *(PLGraphicsIn **)&jarg1; 
01960   result = (unsigned int) ((arg1)->button);
01961   jresult = (jlong)result; 
01962   return jresult;
01963 }
01964 
01965 
01966 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1subwindow_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) {
01967   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
01968   PLINT arg2 ;
01969   
01970   (void)jenv;
01971   (void)jcls;
01972   arg1 = *(PLGraphicsIn **)&jarg1; 
01973   arg2 = (PLINT)jarg2; 
01974   if (arg1) (arg1)->subwindow = arg2;
01975 }
01976 
01977 
01978 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1subwindow_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
01979   jint jresult = 0 ;
01980   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
01981   PLINT result;
01982   
01983   (void)jenv;
01984   (void)jcls;
01985   arg1 = *(PLGraphicsIn **)&jarg1; 
01986   result = (PLINT) ((arg1)->subwindow);
01987   jresult = (jint)result; 
01988   return jresult;
01989 }
01990 
01991 
01992 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1string_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2) {
01993   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
01994   char *arg2 ;
01995   
01996   (void)jenv;
01997   (void)jcls;
01998   arg1 = *(PLGraphicsIn **)&jarg1; 
01999   arg2 = 0;
02000   if (jarg2) {
02001     arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);
02002     if (!arg2) return ;
02003   }
02004   {
02005     if(arg2) {
02006       strncpy((char*)arg1->string, (const char *)arg2, 16-1);
02007       arg1->string[16-1] = 0;
02008     } else {
02009       arg1->string[0] = 0;
02010     }
02011   }
02012   
02013   if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2);
02014 }
02015 
02016 
02017 SWIGEXPORT jstring JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1string_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
02018   jstring jresult = 0 ;
02019   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
02020   char *result = 0 ;
02021   
02022   (void)jenv;
02023   (void)jcls;
02024   arg1 = *(PLGraphicsIn **)&jarg1; 
02025   result = (char *)(char *) ((arg1)->string);
02026   if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result);
02027   return jresult;
02028 }
02029 
02030 
02031 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1pX_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) {
02032   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
02033   int arg2 ;
02034   
02035   (void)jenv;
02036   (void)jcls;
02037   arg1 = *(PLGraphicsIn **)&jarg1; 
02038   arg2 = (int)jarg2; 
02039   if (arg1) (arg1)->pX = arg2;
02040 }
02041 
02042 
02043 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1pX_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
02044   jint jresult = 0 ;
02045   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
02046   int result;
02047   
02048   (void)jenv;
02049   (void)jcls;
02050   arg1 = *(PLGraphicsIn **)&jarg1; 
02051   result = (int) ((arg1)->pX);
02052   jresult = (jint)result; 
02053   return jresult;
02054 }
02055 
02056 
02057 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1pY_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) {
02058   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
02059   int arg2 ;
02060   
02061   (void)jenv;
02062   (void)jcls;
02063   arg1 = *(PLGraphicsIn **)&jarg1; 
02064   arg2 = (int)jarg2; 
02065   if (arg1) (arg1)->pY = arg2;
02066 }
02067 
02068 
02069 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1pY_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
02070   jint jresult = 0 ;
02071   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
02072   int result;
02073   
02074   (void)jenv;
02075   (void)jcls;
02076   arg1 = *(PLGraphicsIn **)&jarg1; 
02077   result = (int) ((arg1)->pY);
02078   jresult = (jint)result; 
02079   return jresult;
02080 }
02081 
02082 
02083 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1dX_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jdouble jarg2) {
02084   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
02085   PLFLT arg2 ;
02086   
02087   (void)jenv;
02088   (void)jcls;
02089   arg1 = *(PLGraphicsIn **)&jarg1; 
02090   arg2 = (PLFLT)jarg2; 
02091   if (arg1) (arg1)->dX = arg2;
02092 }
02093 
02094 
02095 SWIGEXPORT jdouble JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1dX_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
02096   jdouble jresult = 0 ;
02097   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
02098   PLFLT result;
02099   
02100   (void)jenv;
02101   (void)jcls;
02102   arg1 = *(PLGraphicsIn **)&jarg1; 
02103   result = (PLFLT) ((arg1)->dX);
02104   jresult = (jdouble)result; 
02105   return jresult;
02106 }
02107 
02108 
02109 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1dY_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jdouble jarg2) {
02110   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
02111   PLFLT arg2 ;
02112   
02113   (void)jenv;
02114   (void)jcls;
02115   arg1 = *(PLGraphicsIn **)&jarg1; 
02116   arg2 = (PLFLT)jarg2; 
02117   if (arg1) (arg1)->dY = arg2;
02118 }
02119 
02120 
02121 SWIGEXPORT jdouble JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1dY_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
02122   jdouble jresult = 0 ;
02123   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
02124   PLFLT result;
02125   
02126   (void)jenv;
02127   (void)jcls;
02128   arg1 = *(PLGraphicsIn **)&jarg1; 
02129   result = (PLFLT) ((arg1)->dY);
02130   jresult = (jdouble)result; 
02131   return jresult;
02132 }
02133 
02134 
02135 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1wX_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jdouble jarg2) {
02136   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
02137   PLFLT arg2 ;
02138   
02139   (void)jenv;
02140   (void)jcls;
02141   arg1 = *(PLGraphicsIn **)&jarg1; 
02142   arg2 = (PLFLT)jarg2; 
02143   if (arg1) (arg1)->wX = arg2;
02144 }
02145 
02146 
02147 SWIGEXPORT jdouble JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1wX_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
02148   jdouble jresult = 0 ;
02149   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
02150   PLFLT result;
02151   
02152   (void)jenv;
02153   (void)jcls;
02154   arg1 = *(PLGraphicsIn **)&jarg1; 
02155   result = (PLFLT) ((arg1)->wX);
02156   jresult = (jdouble)result; 
02157   return jresult;
02158 }
02159 
02160 
02161 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1wY_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jdouble jarg2) {
02162   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
02163   PLFLT arg2 ;
02164   
02165   (void)jenv;
02166   (void)jcls;
02167   arg1 = *(PLGraphicsIn **)&jarg1; 
02168   arg2 = (PLFLT)jarg2; 
02169   if (arg1) (arg1)->wY = arg2;
02170 }
02171 
02172 
02173 SWIGEXPORT jdouble JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1wY_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
02174   jdouble jresult = 0 ;
02175   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
02176   PLFLT result;
02177   
02178   (void)jenv;
02179   (void)jcls;
02180   arg1 = *(PLGraphicsIn **)&jarg1; 
02181   result = (PLFLT) ((arg1)->wY);
02182   jresult = (jdouble)result; 
02183   return jresult;
02184 }
02185 
02186 
02187 SWIGEXPORT jlong JNICALL Java_plplot_core_plplotjavacJNI_new_1PLGraphicsIn(JNIEnv *jenv, jclass jcls) {
02188   jlong jresult = 0 ;
02189   PLGraphicsIn *result = 0 ;
02190   
02191   (void)jenv;
02192   (void)jcls;
02193   result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
02194   *(PLGraphicsIn **)&jresult = result; 
02195   return jresult;
02196 }
02197 
02198 
02199 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_delete_1PLGraphicsIn(JNIEnv *jenv, jclass jcls, jlong jarg1) {
02200   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
02201   
02202   (void)jenv;
02203   (void)jcls;
02204   arg1 = *(PLGraphicsIn **)&jarg1; 
02205   free((char *) arg1);
02206 }
02207 
02208 
02209 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1MAXWINDOWS_1get(JNIEnv *jenv, jclass jcls) {
02210   jint jresult = 0 ;
02211   int result;
02212   
02213   (void)jenv;
02214   (void)jcls;
02215   result = (int) 64;
02216   jresult = (jint)result; 
02217   return jresult;
02218 }
02219 
02220 
02221 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1NOTSET_1get(JNIEnv *jenv, jclass jcls) {
02222   jint jresult = 0 ;
02223   int result;
02224   
02225   (void)jenv;
02226   (void)jcls;
02227   result = (int) (-42);
02228   jresult = (jint)result; 
02229   return jresult;
02230 }
02231 
02232 
02233 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESPLFLTBUFFERING_1ENABLE_1get(JNIEnv *jenv, jclass jcls) {
02234   jint jresult = 0 ;
02235   int result;
02236   
02237   (void)jenv;
02238   (void)jcls;
02239   result = (int) 1;
02240   jresult = (jint)result; 
02241   return jresult;
02242 }
02243 
02244 
02245 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESPLFLTBUFFERING_1DISABLE_1get(JNIEnv *jenv, jclass jcls) {
02246   jint jresult = 0 ;
02247   int result;
02248   
02249   (void)jenv;
02250   (void)jcls;
02251   result = (int) 2;
02252   jresult = (jint)result; 
02253   return jresult;
02254 }
02255 
02256 
02257 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESPLFLTBUFFERING_1QUERY_1get(JNIEnv *jenv, jclass jcls) {
02258   jint jresult = 0 ;
02259   int result;
02260   
02261   (void)jenv;
02262   (void)jcls;
02263   result = (int) 3;
02264   jresult = (jint)result; 
02265   return jresult;
02266 }
02267 
02268 
02269 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_GRID_1CSA_1get(JNIEnv *jenv, jclass jcls) {
02270   jint jresult = 0 ;
02271   int result;
02272   
02273   (void)jenv;
02274   (void)jcls;
02275   result = (int) 1;
02276   jresult = (jint)result; 
02277   return jresult;
02278 }
02279 
02280 
02281 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_GRID_1DTLI_1get(JNIEnv *jenv, jclass jcls) {
02282   jint jresult = 0 ;
02283   int result;
02284   
02285   (void)jenv;
02286   (void)jcls;
02287   result = (int) 2;
02288   jresult = (jint)result; 
02289   return jresult;
02290 }
02291 
02292 
02293 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_GRID_1NNI_1get(JNIEnv *jenv, jclass jcls) {
02294   jint jresult = 0 ;
02295   int result;
02296   
02297   (void)jenv;
02298   (void)jcls;
02299   result = (int) 3;
02300   jresult = (jint)result; 
02301   return jresult;
02302 }
02303 
02304 
02305 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_GRID_1NNIDW_1get(JNIEnv *jenv, jclass jcls) {
02306   jint jresult = 0 ;
02307   int result;
02308   
02309   (void)jenv;
02310   (void)jcls;
02311   result = (int) 4;
02312   jresult = (jint)result; 
02313   return jresult;
02314 }
02315 
02316 
02317 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_GRID_1NNLI_1get(JNIEnv *jenv, jclass jcls) {
02318   jint jresult = 0 ;
02319   int result;
02320   
02321   (void)jenv;
02322   (void)jcls;
02323   result = (int) 5;
02324   jresult = (jint)result; 
02325   return jresult;
02326 }
02327 
02328 
02329 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_GRID_1NNAIDW_1get(JNIEnv *jenv, jclass jcls) {
02330   jint jresult = 0 ;
02331   int result;
02332   
02333   (void)jenv;
02334   (void)jcls;
02335   result = (int) 6;
02336   jresult = (jint)result; 
02337   return jresult;
02338 }
02339 
02340 
02341 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pl_1setcontlabelformat(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {
02342   PLINT arg1 ;
02343   PLINT arg2 ;
02344   
02345   (void)jenv;
02346   (void)jcls;
02347   arg1 = (PLINT)jarg1; 
02348   arg2 = (PLINT)jarg2; 
02349   pl_setcontlabelformat(arg1,arg2);
02350 }
02351 
02352 
02353 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pl_1setcontlabelparam(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jint jarg4) {
02354   PLFLT arg1 ;
02355   PLFLT arg2 ;
02356   PLFLT arg3 ;
02357   PLINT arg4 ;
02358   
02359   (void)jenv;
02360   (void)jcls;
02361   arg1 = (PLFLT)jarg1; 
02362   arg2 = (PLFLT)jarg2; 
02363   arg3 = (PLFLT)jarg3; 
02364   arg4 = (PLINT)jarg4; 
02365   pl_setcontlabelparam(arg1,arg2,arg3,arg4);
02366 }
02367 
02368 
02369 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pladv(JNIEnv *jenv, jclass jcls, jint jarg1) {
02370   PLINT arg1 ;
02371   
02372   (void)jenv;
02373   (void)jcls;
02374   arg1 = (PLINT)jarg1; 
02375   pladv(arg1);
02376 }
02377 
02378 
02379 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plarc(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4, jdouble jarg5, jdouble jarg6, jdouble jarg7, jboolean jarg8) {
02380   PLFLT arg1 ;
02381   PLFLT arg2 ;
02382   PLFLT arg3 ;
02383   PLFLT arg4 ;
02384   PLFLT arg5 ;
02385   PLFLT arg6 ;
02386   PLFLT arg7 ;
02387   PLBOOL arg8 ;
02388   
02389   (void)jenv;
02390   (void)jcls;
02391   arg1 = (PLFLT)jarg1; 
02392   arg2 = (PLFLT)jarg2; 
02393   arg3 = (PLFLT)jarg3; 
02394   arg4 = (PLFLT)jarg4; 
02395   arg5 = (PLFLT)jarg5; 
02396   arg6 = (PLFLT)jarg6; 
02397   arg7 = (PLFLT)jarg7; 
02398   
02399   arg8 = jarg8 ? 1 : 0;
02400   
02401   plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
02402 }
02403 
02404 
02405 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plaxes(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jstring jarg3, jdouble jarg4, jint jarg5, jstring jarg6, jdouble jarg7, jint jarg8) {
02406   PLFLT arg1 ;
02407   PLFLT arg2 ;
02408   char *arg3 = (char *) 0 ;
02409   PLFLT arg4 ;
02410   PLINT arg5 ;
02411   char *arg6 = (char *) 0 ;
02412   PLFLT arg7 ;
02413   PLINT arg8 ;
02414   
02415   (void)jenv;
02416   (void)jcls;
02417   arg1 = (PLFLT)jarg1; 
02418   arg2 = (PLFLT)jarg2; 
02419   arg3 = 0;
02420   if (jarg3) {
02421     arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0);
02422     if (!arg3) return ;
02423   }
02424   arg4 = (PLFLT)jarg4; 
02425   arg5 = (PLINT)jarg5; 
02426   arg6 = 0;
02427   if (jarg6) {
02428     arg6 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg6, 0);
02429     if (!arg6) return ;
02430   }
02431   arg7 = (PLFLT)jarg7; 
02432   arg8 = (PLINT)jarg8; 
02433   plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
02434   if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3);
02435   if (arg6) (*jenv)->ReleaseStringUTFChars(jenv, jarg6, (const char *)arg6);
02436 }
02437 
02438 
02439 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plbin(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jint jarg4) {
02440   PLINT arg1 ;
02441   PLFLT *arg2 = (PLFLT *) 0 ;
02442   PLFLT *arg3 = (PLFLT *) 0 ;
02443   PLINT arg4 ;
02444   
02445   (void)jenv;
02446   (void)jcls;
02447   {
02448     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
02449     arg1   = ( *jenv )->GetArrayLength( jenv, jarg1 );
02450     Alen = arg1;
02451     setup_array_1d_d( &arg2, jxdata, Alen );
02452     // Could find no easy way to do this as part of freearg so I modified
02453     // the previous function so it ALWAYS mallocs and copies so that
02454     // the java array can be released immediately.
02455     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
02456   }
02457   {
02458     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
02459     if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
02460     {
02461       printf( "Vectors must be same length.\n" );
02462       return;
02463     }
02464     setup_array_1d_d( &arg3, jydata, Alen );
02465     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
02466   }
02467   arg4 = (PLINT)jarg4; 
02468   plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
02469   {
02470     free( arg2 );
02471   }
02472   {
02473     free( arg3 );
02474   }
02475 }
02476 
02477 
02478 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plbtime(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2, jintArray jarg3, jintArray jarg4, jintArray jarg5, jdoubleArray jarg6, jdouble jarg7) {
02479   PLINT *arg1 = (PLINT *) 0 ;
02480   PLINT *arg2 = (PLINT *) 0 ;
02481   PLINT *arg3 = (PLINT *) 0 ;
02482   PLINT *arg4 = (PLINT *) 0 ;
02483   PLINT *arg5 = (PLINT *) 0 ;
02484   PLFLT *arg6 = (PLFLT *) 0 ;
02485   PLFLT arg7 ;
02486   PLINT temp1 ;
02487   PLINT temp2 ;
02488   PLINT temp3 ;
02489   PLINT temp4 ;
02490   PLINT temp5 ;
02491   PLFLT temp6 ;
02492   
02493   (void)jenv;
02494   (void)jcls;
02495   {
02496     if (!jarg1) {
02497       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
02498       return ;
02499     }
02500     if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
02501       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
02502       return ;
02503     }
02504     arg1 = &temp1; 
02505   }
02506   {
02507     if (!jarg2) {
02508       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
02509       return ;
02510     }
02511     if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
02512       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
02513       return ;
02514     }
02515     arg2 = &temp2; 
02516   }
02517   {
02518     if (!jarg3) {
02519       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
02520       return ;
02521     }
02522     if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
02523       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
02524       return ;
02525     }
02526     arg3 = &temp3; 
02527   }
02528   {
02529     if (!jarg4) {
02530       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
02531       return ;
02532     }
02533     if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
02534       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
02535       return ;
02536     }
02537     arg4 = &temp4; 
02538   }
02539   {
02540     if (!jarg5) {
02541       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
02542       return ;
02543     }
02544     if ((*jenv)->GetArrayLength(jenv, jarg5) == 0) {
02545       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
02546       return ;
02547     }
02548     arg5 = &temp5; 
02549   }
02550   {
02551     if (!jarg6) {
02552       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
02553       return ;
02554     }
02555     if ((*jenv)->GetArrayLength(jenv, jarg6) == 0) {
02556       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
02557       return ;
02558     }
02559     arg6 = &temp6; 
02560   }
02561   arg7 = (PLFLT)jarg7; 
02562   plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
02563   {
02564     jint jvalue = (jint)temp1;
02565     (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
02566   }
02567   {
02568     jint jvalue = (jint)temp2;
02569     (*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);
02570   }
02571   {
02572     jint jvalue = (jint)temp3;
02573     (*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);
02574   }
02575   {
02576     jint jvalue = (jint)temp4;
02577     (*jenv)->SetIntArrayRegion(jenv, jarg4, 0, 1, &jvalue);
02578   }
02579   {
02580     jint jvalue = (jint)temp5;
02581     (*jenv)->SetIntArrayRegion(jenv, jarg5, 0, 1, &jvalue);
02582   }
02583   {
02584     jdouble jvalue = (jdouble)temp6;
02585     (*jenv)->SetDoubleArrayRegion(jenv, jarg6, 0, 1, &jvalue);
02586   }
02587   
02588   
02589   
02590   
02591   
02592   
02593 }
02594 
02595 
02596 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plbop(JNIEnv *jenv, jclass jcls) {
02597   (void)jenv;
02598   (void)jcls;
02599   plbop();
02600 }
02601 
02602 
02603 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plbox(JNIEnv *jenv, jclass jcls, jstring jarg1, jdouble jarg2, jint jarg3, jstring jarg4, jdouble jarg5, jint jarg6) {
02604   char *arg1 = (char *) 0 ;
02605   PLFLT arg2 ;
02606   PLINT arg3 ;
02607   char *arg4 = (char *) 0 ;
02608   PLFLT arg5 ;
02609   PLINT arg6 ;
02610   
02611   (void)jenv;
02612   (void)jcls;
02613   arg1 = 0;
02614   if (jarg1) {
02615     arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
02616     if (!arg1) return ;
02617   }
02618   arg2 = (PLFLT)jarg2; 
02619   arg3 = (PLINT)jarg3; 
02620   arg4 = 0;
02621   if (jarg4) {
02622     arg4 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg4, 0);
02623     if (!arg4) return ;
02624   }
02625   arg5 = (PLFLT)jarg5; 
02626   arg6 = (PLINT)jarg6; 
02627   plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
02628   if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
02629   if (arg4) (*jenv)->ReleaseStringUTFChars(jenv, jarg4, (const char *)arg4);
02630 }
02631 
02632 
02633 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plbox3(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2, jdouble jarg3, jint jarg4, jstring jarg5, jstring jarg6, jdouble jarg7, jint jarg8, jstring jarg9, jstring jarg10, jdouble jarg11, jint jarg12) {
02634   char *arg1 = (char *) 0 ;
02635   char *arg2 = (char *) 0 ;
02636   PLFLT arg3 ;
02637   PLINT arg4 ;
02638   char *arg5 = (char *) 0 ;
02639   char *arg6 = (char *) 0 ;
02640   PLFLT arg7 ;
02641   PLINT arg8 ;
02642   char *arg9 = (char *) 0 ;
02643   char *arg10 = (char *) 0 ;
02644   PLFLT arg11 ;
02645   PLINT arg12 ;
02646   
02647   (void)jenv;
02648   (void)jcls;
02649   arg1 = 0;
02650   if (jarg1) {
02651     arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
02652     if (!arg1) return ;
02653   }
02654   arg2 = 0;
02655   if (jarg2) {
02656     arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);
02657     if (!arg2) return ;
02658   }
02659   arg3 = (PLFLT)jarg3; 
02660   arg4 = (PLINT)jarg4; 
02661   arg5 = 0;
02662   if (jarg5) {
02663     arg5 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg5, 0);
02664     if (!arg5) return ;
02665   }
02666   arg6 = 0;
02667   if (jarg6) {
02668     arg6 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg6, 0);
02669     if (!arg6) return ;
02670   }
02671   arg7 = (PLFLT)jarg7; 
02672   arg8 = (PLINT)jarg8; 
02673   arg9 = 0;
02674   if (jarg9) {
02675     arg9 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg9, 0);
02676     if (!arg9) return ;
02677   }
02678   arg10 = 0;
02679   if (jarg10) {
02680     arg10 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg10, 0);
02681     if (!arg10) return ;
02682   }
02683   arg11 = (PLFLT)jarg11; 
02684   arg12 = (PLINT)jarg12; 
02685   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);
02686   if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
02687   if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2);
02688   if (arg5) (*jenv)->ReleaseStringUTFChars(jenv, jarg5, (const char *)arg5);
02689   if (arg6) (*jenv)->ReleaseStringUTFChars(jenv, jarg6, (const char *)arg6);
02690   if (arg9) (*jenv)->ReleaseStringUTFChars(jenv, jarg9, (const char *)arg9);
02691   if (arg10) (*jenv)->ReleaseStringUTFChars(jenv, jarg10, (const char *)arg10);
02692 }
02693 
02694 
02695 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plcalc_1world(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdoubleArray jarg3, jdoubleArray jarg4, jintArray jarg5) {
02696   PLFLT arg1 ;
02697   PLFLT arg2 ;
02698   PLFLT *arg3 = (PLFLT *) 0 ;
02699   PLFLT *arg4 = (PLFLT *) 0 ;
02700   PLINT *arg5 = (PLINT *) 0 ;
02701   PLFLT temp3 ;
02702   PLFLT temp4 ;
02703   PLINT temp5 ;
02704   
02705   (void)jenv;
02706   (void)jcls;
02707   arg1 = (PLFLT)jarg1; 
02708   arg2 = (PLFLT)jarg2; 
02709   {
02710     if (!jarg3) {
02711       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
02712       return ;
02713     }
02714     if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
02715       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
02716       return ;
02717     }
02718     arg3 = &temp3; 
02719   }
02720   {
02721     if (!jarg4) {
02722       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
02723       return ;
02724     }
02725     if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
02726       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
02727       return ;
02728     }
02729     arg4 = &temp4; 
02730   }
02731   {
02732     if (!jarg5) {
02733       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
02734       return ;
02735     }
02736     if ((*jenv)->GetArrayLength(jenv, jarg5) == 0) {
02737       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
02738       return ;
02739     }
02740     arg5 = &temp5; 
02741   }
02742   plcalc_world(arg1,arg2,arg3,arg4,arg5);
02743   {
02744     jdouble jvalue = (jdouble)temp3;
02745     (*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);
02746   }
02747   {
02748     jdouble jvalue = (jdouble)temp4;
02749     (*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);
02750   }
02751   {
02752     jint jvalue = (jint)temp5;
02753     (*jenv)->SetIntArrayRegion(jenv, jarg5, 0, 1, &jvalue);
02754   }
02755   
02756   
02757   
02758 }
02759 
02760 
02761 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plclear(JNIEnv *jenv, jclass jcls) {
02762   (void)jenv;
02763   (void)jcls;
02764   plclear();
02765 }
02766 
02767 
02768 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plcol0(JNIEnv *jenv, jclass jcls, jint jarg1) {
02769   PLINT arg1 ;
02770   
02771   (void)jenv;
02772   (void)jcls;
02773   arg1 = (PLINT)jarg1; 
02774   plcol0(arg1);
02775 }
02776 
02777 
02778 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plcol1(JNIEnv *jenv, jclass jcls, jdouble jarg1) {
02779   PLFLT arg1 ;
02780   
02781   (void)jenv;
02782   (void)jcls;
02783   arg1 = (PLFLT)jarg1; 
02784   plcol1(arg1);
02785 }
02786 
02787 
02788 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plconfigtime(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jint jarg4, jboolean jarg5, jint jarg6, jint jarg7, jint jarg8, jint jarg9, jint jarg10, jdouble jarg11) {
02789   PLFLT arg1 ;
02790   PLFLT arg2 ;
02791   PLFLT arg3 ;
02792   PLINT arg4 ;
02793   PLBOOL arg5 ;
02794   PLINT arg6 ;
02795   PLINT arg7 ;
02796   PLINT arg8 ;
02797   PLINT arg9 ;
02798   PLINT arg10 ;
02799   PLFLT arg11 ;
02800   
02801   (void)jenv;
02802   (void)jcls;
02803   arg1 = (PLFLT)jarg1; 
02804   arg2 = (PLFLT)jarg2; 
02805   arg3 = (PLFLT)jarg3; 
02806   arg4 = (PLINT)jarg4; 
02807   
02808   arg5 = jarg5 ? 1 : 0;
02809   
02810   arg6 = (PLINT)jarg6; 
02811   arg7 = (PLINT)jarg7; 
02812   arg8 = (PLINT)jarg8; 
02813   arg9 = (PLINT)jarg9; 
02814   arg10 = (PLINT)jarg10; 
02815   arg11 = (PLFLT)jarg11; 
02816   plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
02817 }
02818 
02819 
02820 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plcont(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jdoubleArray jarg8, jobjectArray jarg10, jobjectArray jarg11) {
02821   PLFLT **arg1 = (PLFLT **) 0 ;
02822   PLINT arg2 ;
02823   PLINT arg3 ;
02824   PLINT arg4 ;
02825   PLINT arg5 ;
02826   PLINT arg6 ;
02827   PLINT arg7 ;
02828   PLFLT *arg8 = (PLFLT *) 0 ;
02829   PLINT arg9 ;
02830   pltr_func arg10 ;
02831   PLPointer arg11 = (PLPointer) 0 ;
02832   
02833   (void)jenv;
02834   (void)jcls;
02835   {
02836     jdouble  **adat;
02837     jobject *ai;
02838     int     nx = ( *jenv )->GetArrayLength( jenv, jarg1 );
02839     int     ny = -1;
02840     int     i, j;
02841     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
02842     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
02843     
02844     ( *jenv )->EnsureLocalCapacity( jenv, nx );
02845     
02846     for ( i = 0; i < nx; i++ )
02847     {
02848       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg1, i );
02849       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
02850       
02851       if ( ny == -1 )
02852       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
02853       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
02854       {
02855         printf( "Misshapen a array.\n" );
02856         for ( j = 0; j <= i; j++ )
02857         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
02858         free( adat );
02859         free( ai );
02860         return;
02861       }
02862     }
02863     
02864     Xlen = nx;
02865     Ylen = ny;
02866     setup_array_2d_d( &arg1, adat, nx, ny );
02867     arg2 = nx;
02868     arg3 = ny;
02869     for ( i = 0; i < nx; i++ )
02870     {
02871       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
02872       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
02873     }
02874     
02875     free( adat );
02876     free( ai );
02877   }
02878   arg4 = (PLINT)jarg4; 
02879   arg5 = (PLINT)jarg5; 
02880   arg6 = (PLINT)jarg6; 
02881   arg7 = (PLINT)jarg7; 
02882   {
02883     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg8, 0 );
02884     arg9 = ( *jenv )->GetArrayLength( jenv, jarg8 );
02885     setup_array_1d_d( &arg8, jxdata, arg9 );
02886     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg8, jxdata, 0 );
02887   }
02888   {
02889     jdouble  **adat;
02890     jobject *ai;
02891     int     nx = ( *jenv )->GetArrayLength( jenv, jarg10 );
02892     int     ny = -1;
02893     int     i, j;
02894     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
02895     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
02896     
02897     ( *jenv )->EnsureLocalCapacity( jenv, nx );
02898     
02899     for ( i = 0; i < nx; i++ )
02900     {
02901       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg10, i );
02902       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
02903       
02904       if ( ny == -1 )
02905       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
02906       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
02907       {
02908         printf( "Misshapen a array.\n" );
02909         for ( j = 0; j <= i; j++ )
02910         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
02911         free( adat );
02912         free( ai );
02913         return;
02914       }
02915     }
02916     
02917     if ( !( ( nx == Xlen && ny == Ylen ) || ( nx == Xlen && ny == 1 ) ) )
02918     {
02919       printf( "Xlen =%d, nx =%d, Ylen =%d, ny =%d\n", Xlen, nx, Ylen, ny );
02920       printf( "X vector or matrix must match matrix dimensions.\n" );
02921       for ( i = 0; i < nx; i++ )
02922       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
02923       free( adat );
02924       free( ai );
02925       return;
02926     }
02927     // Store whether second dimension is unity.
02928     Alen = ny;
02929     setup_array_2d_d( &xg, adat, nx, ny );
02930     for ( i = 0; i < nx; i++ )
02931     {
02932       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
02933       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
02934     }
02935     
02936     free( adat );
02937     free( ai );
02938     arg10 = pltr2;
02939   }
02940   {
02941     jdouble   **adat;
02942     jobject  *ai;
02943     int      nx = ( *jenv )->GetArrayLength( jenv, jarg11 );
02944     int      ny = -1;
02945     int      i, j;
02946     PLcGrid2 cgrid;
02947     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
02948     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
02949     
02950     ( *jenv )->EnsureLocalCapacity( jenv, nx );
02951     
02952     for ( i = 0; i < nx; i++ )
02953     {
02954       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg11, i );
02955       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
02956       
02957       if ( ny == -1 )
02958       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
02959       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
02960       {
02961         printf( "Misshapen a array.\n" );
02962         for ( j = 0; j <= i; j++ )
02963         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
02964         free( adat );
02965         free( ai );
02966         return;
02967       }
02968     }
02969     
02970     if ( !( ( nx == Xlen && ny == Ylen ) || ( nx == Ylen && ny == 1 && ny == Alen ) ) )
02971     {
02972       printf( "Xlen =%d, nx =%d, Ylen =%d, Alen =%d, ny =%d\n",
02973         Xlen, nx, Ylen, Alen, ny );
02974       printf( "Y vector or matrix must match matrix dimensions.\n" );
02975       for ( i = 0; i < nx; i++ )
02976       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
02977       free( adat );
02978       free( ai );
02979       return;
02980     }
02981     setup_array_2d_d( &yg, adat, nx, ny );
02982     for ( i = 0; i < nx; i++ )
02983     {
02984       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
02985       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
02986     }
02987     
02988     free( adat );
02989     free( ai );
02990     cgrid.xg = xg;
02991     cgrid.yg = yg;
02992     cgrid.nx = nx;
02993     cgrid.ny = ny;
02994     arg11       = &cgrid;
02995   }
02996   plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
02997   {
02998     free( arg1[0] );
02999     free( arg1 );
03000   }
03001   {
03002     free( arg8 );
03003   }
03004   {
03005     free( xg[0] );
03006     free( xg );
03007   }
03008   {
03009     free( yg[0] );
03010     free( yg );
03011   }
03012 }
03013 
03014 
03015 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plctime(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jdouble jarg6, jdoubleArray jarg7) {
03016   PLINT arg1 ;
03017   PLINT arg2 ;
03018   PLINT arg3 ;
03019   PLINT arg4 ;
03020   PLINT arg5 ;
03021   PLFLT arg6 ;
03022   PLFLT *arg7 = (PLFLT *) 0 ;
03023   PLFLT temp7 ;
03024   
03025   (void)jenv;
03026   (void)jcls;
03027   arg1 = (PLINT)jarg1; 
03028   arg2 = (PLINT)jarg2; 
03029   arg3 = (PLINT)jarg3; 
03030   arg4 = (PLINT)jarg4; 
03031   arg5 = (PLINT)jarg5; 
03032   arg6 = (PLFLT)jarg6; 
03033   {
03034     if (!jarg7) {
03035       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03036       return ;
03037     }
03038     if ((*jenv)->GetArrayLength(jenv, jarg7) == 0) {
03039       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03040       return ;
03041     }
03042     arg7 = &temp7; 
03043   }
03044   plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
03045   {
03046     jdouble jvalue = (jdouble)temp7;
03047     (*jenv)->SetDoubleArrayRegion(jenv, jarg7, 0, 1, &jvalue);
03048   }
03049   
03050 }
03051 
03052 
03053 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plcpstrm(JNIEnv *jenv, jclass jcls, jint jarg1, jboolean jarg2) {
03054   PLINT arg1 ;
03055   PLBOOL arg2 ;
03056   
03057   (void)jenv;
03058   (void)jcls;
03059   arg1 = (PLINT)jarg1; 
03060   
03061   arg2 = jarg2 ? 1 : 0;
03062   
03063   plcpstrm(arg1,arg2);
03064 }
03065 
03066 
03067 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plend(JNIEnv *jenv, jclass jcls) {
03068   (void)jenv;
03069   (void)jcls;
03070   plend();
03071 }
03072 
03073 
03074 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plend1(JNIEnv *jenv, jclass jcls) {
03075   (void)jenv;
03076   (void)jcls;
03077   plend1();
03078 }
03079 
03080 
03081 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plenv(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4, jint jarg5, jint jarg6) {
03082   PLFLT arg1 ;
03083   PLFLT arg2 ;
03084   PLFLT arg3 ;
03085   PLFLT arg4 ;
03086   PLINT arg5 ;
03087   PLINT arg6 ;
03088   
03089   (void)jenv;
03090   (void)jcls;
03091   arg1 = (PLFLT)jarg1; 
03092   arg2 = (PLFLT)jarg2; 
03093   arg3 = (PLFLT)jarg3; 
03094   arg4 = (PLFLT)jarg4; 
03095   arg5 = (PLINT)jarg5; 
03096   arg6 = (PLINT)jarg6; 
03097   plenv(arg1,arg2,arg3,arg4,arg5,arg6);
03098 }
03099 
03100 
03101 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plenv0(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4, jint jarg5, jint jarg6) {
03102   PLFLT arg1 ;
03103   PLFLT arg2 ;
03104   PLFLT arg3 ;
03105   PLFLT arg4 ;
03106   PLINT arg5 ;
03107   PLINT arg6 ;
03108   
03109   (void)jenv;
03110   (void)jcls;
03111   arg1 = (PLFLT)jarg1; 
03112   arg2 = (PLFLT)jarg2; 
03113   arg3 = (PLFLT)jarg3; 
03114   arg4 = (PLFLT)jarg4; 
03115   arg5 = (PLINT)jarg5; 
03116   arg6 = (PLINT)jarg6; 
03117   plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
03118 }
03119 
03120 
03121 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pleop(JNIEnv *jenv, jclass jcls) {
03122   (void)jenv;
03123   (void)jcls;
03124   pleop();
03125 }
03126 
03127 
03128 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plerrx(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jdoubleArray jarg4) {
03129   PLINT arg1 ;
03130   PLFLT *arg2 = (PLFLT *) 0 ;
03131   PLFLT *arg3 = (PLFLT *) 0 ;
03132   PLFLT *arg4 = (PLFLT *) 0 ;
03133   
03134   (void)jenv;
03135   (void)jcls;
03136   {
03137     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
03138     arg1   = ( *jenv )->GetArrayLength( jenv, jarg1 );
03139     Alen = arg1;
03140     setup_array_1d_d( &arg2, jxdata, Alen );
03141     // Could find no easy way to do this as part of freearg so I modified
03142     // the previous function so it ALWAYS mallocs and copies so that
03143     // the java array can be released immediately.
03144     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
03145   }
03146   {
03147     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
03148     if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
03149     {
03150       printf( "Vectors must be same length.\n" );
03151       return;
03152     }
03153     setup_array_1d_d( &arg3, jydata, Alen );
03154     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
03155   }
03156   {
03157     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg4, 0 );
03158     if ( ( *jenv )->GetArrayLength( jenv, jarg4 ) != Alen )
03159     {
03160       printf( "Vectors must be same length.\n" );
03161       return;
03162     }
03163     setup_array_1d_d( &arg4, jydata, Alen );
03164     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );
03165   }
03166   plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
03167   {
03168     free( arg2 );
03169   }
03170   {
03171     free( arg3 );
03172   }
03173   {
03174     free( arg4 );
03175   }
03176 }
03177 
03178 
03179 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plerry(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jdoubleArray jarg4) {
03180   PLINT arg1 ;
03181   PLFLT *arg2 = (PLFLT *) 0 ;
03182   PLFLT *arg3 = (PLFLT *) 0 ;
03183   PLFLT *arg4 = (PLFLT *) 0 ;
03184   
03185   (void)jenv;
03186   (void)jcls;
03187   {
03188     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
03189     arg1   = ( *jenv )->GetArrayLength( jenv, jarg1 );
03190     Alen = arg1;
03191     setup_array_1d_d( &arg2, jxdata, Alen );
03192     // Could find no easy way to do this as part of freearg so I modified
03193     // the previous function so it ALWAYS mallocs and copies so that
03194     // the java array can be released immediately.
03195     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
03196   }
03197   {
03198     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
03199     if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
03200     {
03201       printf( "Vectors must be same length.\n" );
03202       return;
03203     }
03204     setup_array_1d_d( &arg3, jydata, Alen );
03205     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
03206   }
03207   {
03208     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg4, 0 );
03209     if ( ( *jenv )->GetArrayLength( jenv, jarg4 ) != Alen )
03210     {
03211       printf( "Vectors must be same length.\n" );
03212       return;
03213     }
03214     setup_array_1d_d( &arg4, jydata, Alen );
03215     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );
03216   }
03217   plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
03218   {
03219     free( arg2 );
03220   }
03221   {
03222     free( arg3 );
03223   }
03224   {
03225     free( arg4 );
03226   }
03227 }
03228 
03229 
03230 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plfamadv(JNIEnv *jenv, jclass jcls) {
03231   (void)jenv;
03232   (void)jcls;
03233   plfamadv();
03234 }
03235 
03236 
03237 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plfill(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3) {
03238   PLINT arg1 ;
03239   PLFLT *arg2 = (PLFLT *) 0 ;
03240   PLFLT *arg3 = (PLFLT *) 0 ;
03241   
03242   (void)jenv;
03243   (void)jcls;
03244   {
03245     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
03246     arg1   = ( *jenv )->GetArrayLength( jenv, jarg1 );
03247     Alen = arg1;
03248     setup_array_1d_d( &arg2, jxdata, Alen );
03249     // Could find no easy way to do this as part of freearg so I modified
03250     // the previous function so it ALWAYS mallocs and copies so that
03251     // the java array can be released immediately.
03252     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
03253   }
03254   {
03255     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
03256     if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
03257     {
03258       printf( "Vectors must be same length.\n" );
03259       return;
03260     }
03261     setup_array_1d_d( &arg3, jydata, Alen );
03262     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
03263   }
03264   plfill(arg1,(double const *)arg2,(double const *)arg3);
03265   {
03266     free( arg2 );
03267   }
03268   {
03269     free( arg3 );
03270   }
03271 }
03272 
03273 
03274 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plfill3(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jdoubleArray jarg4) {
03275   PLINT arg1 ;
03276   PLFLT *arg2 = (PLFLT *) 0 ;
03277   PLFLT *arg3 = (PLFLT *) 0 ;
03278   PLFLT *arg4 = (PLFLT *) 0 ;
03279   
03280   (void)jenv;
03281   (void)jcls;
03282   {
03283     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
03284     arg1   = ( *jenv )->GetArrayLength( jenv, jarg1 );
03285     Alen = arg1;
03286     setup_array_1d_d( &arg2, jxdata, Alen );
03287     // Could find no easy way to do this as part of freearg so I modified
03288     // the previous function so it ALWAYS mallocs and copies so that
03289     // the java array can be released immediately.
03290     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
03291   }
03292   {
03293     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
03294     if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
03295     {
03296       printf( "Vectors must be same length.\n" );
03297       return;
03298     }
03299     setup_array_1d_d( &arg3, jydata, Alen );
03300     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
03301   }
03302   {
03303     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg4, 0 );
03304     if ( ( *jenv )->GetArrayLength( jenv, jarg4 ) != Alen )
03305     {
03306       printf( "Vectors must be same length.\n" );
03307       return;
03308     }
03309     setup_array_1d_d( &arg4, jydata, Alen );
03310     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );
03311   }
03312   plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
03313   {
03314     free( arg2 );
03315   }
03316   {
03317     free( arg3 );
03318   }
03319   {
03320     free( arg4 );
03321   }
03322 }
03323 
03324 
03325 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgradient(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jdouble jarg4) {
03326   PLINT arg1 ;
03327   PLFLT *arg2 = (PLFLT *) 0 ;
03328   PLFLT *arg3 = (PLFLT *) 0 ;
03329   PLFLT arg4 ;
03330   
03331   (void)jenv;
03332   (void)jcls;
03333   {
03334     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
03335     arg1   = ( *jenv )->GetArrayLength( jenv, jarg1 );
03336     Alen = arg1;
03337     setup_array_1d_d( &arg2, jxdata, Alen );
03338     // Could find no easy way to do this as part of freearg so I modified
03339     // the previous function so it ALWAYS mallocs and copies so that
03340     // the java array can be released immediately.
03341     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
03342   }
03343   {
03344     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
03345     if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
03346     {
03347       printf( "Vectors must be same length.\n" );
03348       return;
03349     }
03350     setup_array_1d_d( &arg3, jydata, Alen );
03351     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
03352   }
03353   arg4 = (PLFLT)jarg4; 
03354   plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
03355   {
03356     free( arg2 );
03357   }
03358   {
03359     free( arg3 );
03360   }
03361 }
03362 
03363 
03364 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plflush(JNIEnv *jenv, jclass jcls) {
03365   (void)jenv;
03366   (void)jcls;
03367   plflush();
03368 }
03369 
03370 
03371 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plfont(JNIEnv *jenv, jclass jcls, jint jarg1) {
03372   PLINT arg1 ;
03373   
03374   (void)jenv;
03375   (void)jcls;
03376   arg1 = (PLINT)jarg1; 
03377   plfont(arg1);
03378 }
03379 
03380 
03381 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plfontld(JNIEnv *jenv, jclass jcls, jint jarg1) {
03382   PLINT arg1 ;
03383   
03384   (void)jenv;
03385   (void)jcls;
03386   arg1 = (PLINT)jarg1; 
03387   plfontld(arg1);
03388 }
03389 
03390 
03391 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgchr(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2) {
03392   PLFLT *arg1 = (PLFLT *) 0 ;
03393   PLFLT *arg2 = (PLFLT *) 0 ;
03394   PLFLT temp1 ;
03395   PLFLT temp2 ;
03396   
03397   (void)jenv;
03398   (void)jcls;
03399   {
03400     if (!jarg1) {
03401       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03402       return ;
03403     }
03404     if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
03405       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03406       return ;
03407     }
03408     arg1 = &temp1; 
03409   }
03410   {
03411     if (!jarg2) {
03412       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03413       return ;
03414     }
03415     if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
03416       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03417       return ;
03418     }
03419     arg2 = &temp2; 
03420   }
03421   plgchr(arg1,arg2);
03422   {
03423     jdouble jvalue = (jdouble)temp1;
03424     (*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);
03425   }
03426   {
03427     jdouble jvalue = (jdouble)temp2;
03428     (*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);
03429   }
03430   
03431   
03432 }
03433 
03434 
03435 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgcol0(JNIEnv *jenv, jclass jcls, jint jarg1, jintArray jarg2, jintArray jarg3, jintArray jarg4) {
03436   PLINT arg1 ;
03437   PLINT *arg2 = (PLINT *) 0 ;
03438   PLINT *arg3 = (PLINT *) 0 ;
03439   PLINT *arg4 = (PLINT *) 0 ;
03440   PLINT temp2 ;
03441   PLINT temp3 ;
03442   PLINT temp4 ;
03443   
03444   (void)jenv;
03445   (void)jcls;
03446   arg1 = (PLINT)jarg1; 
03447   {
03448     if (!jarg2) {
03449       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03450       return ;
03451     }
03452     if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
03453       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03454       return ;
03455     }
03456     arg2 = &temp2; 
03457   }
03458   {
03459     if (!jarg3) {
03460       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03461       return ;
03462     }
03463     if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
03464       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03465       return ;
03466     }
03467     arg3 = &temp3; 
03468   }
03469   {
03470     if (!jarg4) {
03471       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03472       return ;
03473     }
03474     if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
03475       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03476       return ;
03477     }
03478     arg4 = &temp4; 
03479   }
03480   plgcol0(arg1,arg2,arg3,arg4);
03481   {
03482     jint jvalue = (jint)temp2;
03483     (*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);
03484   }
03485   {
03486     jint jvalue = (jint)temp3;
03487     (*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);
03488   }
03489   {
03490     jint jvalue = (jint)temp4;
03491     (*jenv)->SetIntArrayRegion(jenv, jarg4, 0, 1, &jvalue);
03492   }
03493   
03494   
03495   
03496 }
03497 
03498 
03499 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgcol0a(JNIEnv *jenv, jclass jcls, jint jarg1, jintArray jarg2, jintArray jarg3, jintArray jarg4, jdoubleArray jarg5) {
03500   PLINT arg1 ;
03501   PLINT *arg2 = (PLINT *) 0 ;
03502   PLINT *arg3 = (PLINT *) 0 ;
03503   PLINT *arg4 = (PLINT *) 0 ;
03504   PLFLT *arg5 = (PLFLT *) 0 ;
03505   PLINT temp2 ;
03506   PLINT temp3 ;
03507   PLINT temp4 ;
03508   PLFLT temp5 ;
03509   
03510   (void)jenv;
03511   (void)jcls;
03512   arg1 = (PLINT)jarg1; 
03513   {
03514     if (!jarg2) {
03515       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03516       return ;
03517     }
03518     if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
03519       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03520       return ;
03521     }
03522     arg2 = &temp2; 
03523   }
03524   {
03525     if (!jarg3) {
03526       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03527       return ;
03528     }
03529     if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
03530       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03531       return ;
03532     }
03533     arg3 = &temp3; 
03534   }
03535   {
03536     if (!jarg4) {
03537       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03538       return ;
03539     }
03540     if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
03541       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03542       return ;
03543     }
03544     arg4 = &temp4; 
03545   }
03546   {
03547     if (!jarg5) {
03548       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03549       return ;
03550     }
03551     if ((*jenv)->GetArrayLength(jenv, jarg5) == 0) {
03552       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03553       return ;
03554     }
03555     arg5 = &temp5; 
03556   }
03557   plgcol0a(arg1,arg2,arg3,arg4,arg5);
03558   {
03559     jint jvalue = (jint)temp2;
03560     (*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);
03561   }
03562   {
03563     jint jvalue = (jint)temp3;
03564     (*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);
03565   }
03566   {
03567     jint jvalue = (jint)temp4;
03568     (*jenv)->SetIntArrayRegion(jenv, jarg4, 0, 1, &jvalue);
03569   }
03570   {
03571     jdouble jvalue = (jdouble)temp5;
03572     (*jenv)->SetDoubleArrayRegion(jenv, jarg5, 0, 1, &jvalue);
03573   }
03574   
03575   
03576   
03577   
03578 }
03579 
03580 
03581 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgcolbg(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2, jintArray jarg3) {
03582   PLINT *arg1 = (PLINT *) 0 ;
03583   PLINT *arg2 = (PLINT *) 0 ;
03584   PLINT *arg3 = (PLINT *) 0 ;
03585   PLINT temp1 ;
03586   PLINT temp2 ;
03587   PLINT temp3 ;
03588   
03589   (void)jenv;
03590   (void)jcls;
03591   {
03592     if (!jarg1) {
03593       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03594       return ;
03595     }
03596     if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
03597       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03598       return ;
03599     }
03600     arg1 = &temp1; 
03601   }
03602   {
03603     if (!jarg2) {
03604       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03605       return ;
03606     }
03607     if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
03608       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03609       return ;
03610     }
03611     arg2 = &temp2; 
03612   }
03613   {
03614     if (!jarg3) {
03615       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03616       return ;
03617     }
03618     if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
03619       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03620       return ;
03621     }
03622     arg3 = &temp3; 
03623   }
03624   plgcolbg(arg1,arg2,arg3);
03625   {
03626     jint jvalue = (jint)temp1;
03627     (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
03628   }
03629   {
03630     jint jvalue = (jint)temp2;
03631     (*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);
03632   }
03633   {
03634     jint jvalue = (jint)temp3;
03635     (*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);
03636   }
03637   
03638   
03639   
03640 }
03641 
03642 
03643 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgcolbga(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2, jintArray jarg3, jdoubleArray jarg4) {
03644   PLINT *arg1 = (PLINT *) 0 ;
03645   PLINT *arg2 = (PLINT *) 0 ;
03646   PLINT *arg3 = (PLINT *) 0 ;
03647   PLFLT *arg4 = (PLFLT *) 0 ;
03648   PLINT temp1 ;
03649   PLINT temp2 ;
03650   PLINT temp3 ;
03651   PLFLT temp4 ;
03652   
03653   (void)jenv;
03654   (void)jcls;
03655   {
03656     if (!jarg1) {
03657       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03658       return ;
03659     }
03660     if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
03661       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03662       return ;
03663     }
03664     arg1 = &temp1; 
03665   }
03666   {
03667     if (!jarg2) {
03668       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03669       return ;
03670     }
03671     if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
03672       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03673       return ;
03674     }
03675     arg2 = &temp2; 
03676   }
03677   {
03678     if (!jarg3) {
03679       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03680       return ;
03681     }
03682     if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
03683       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03684       return ;
03685     }
03686     arg3 = &temp3; 
03687   }
03688   {
03689     if (!jarg4) {
03690       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03691       return ;
03692     }
03693     if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
03694       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03695       return ;
03696     }
03697     arg4 = &temp4; 
03698   }
03699   plgcolbga(arg1,arg2,arg3,arg4);
03700   {
03701     jint jvalue = (jint)temp1;
03702     (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
03703   }
03704   {
03705     jint jvalue = (jint)temp2;
03706     (*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);
03707   }
03708   {
03709     jint jvalue = (jint)temp3;
03710     (*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);
03711   }
03712   {
03713     jdouble jvalue = (jdouble)temp4;
03714     (*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);
03715   }
03716   
03717   
03718   
03719   
03720 }
03721 
03722 
03723 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgcompression(JNIEnv *jenv, jclass jcls, jintArray jarg1) {
03724   PLINT *arg1 = (PLINT *) 0 ;
03725   PLINT temp1 ;
03726   
03727   (void)jenv;
03728   (void)jcls;
03729   {
03730     if (!jarg1) {
03731       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03732       return ;
03733     }
03734     if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
03735       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03736       return ;
03737     }
03738     arg1 = &temp1; 
03739   }
03740   plgcompression(arg1);
03741   {
03742     jint jvalue = (jint)temp1;
03743     (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
03744   }
03745   
03746 }
03747 
03748 
03749 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgdev(JNIEnv *jenv, jclass jcls, jobject jarg1) {
03750   char *arg1 = (char *) 0 ;
03751   
03752   (void)jenv;
03753   (void)jcls;
03754   {
03755     arg1 = NULL;
03756     if ( jarg1 != NULL )
03757     {
03758       // Get the String from the StringBuffer
03759       jmethodID setLengthID;
03760       jclass    sbufClass = ( *jenv )->GetObjectClass( jenv, jarg1 );
03761       // Take a copy of the C string as the typemap is for a non const C string
03762       jmethodID capacityID = ( *jenv )->GetMethodID( jenv, sbufClass, "capacity", "()I" );
03763       jint      capacity   = ( *jenv )->CallIntMethod( jenv, jarg1, capacityID );
03764       arg1 = (char *) malloc( capacity + 1 );
03765       
03766       // Zero the original StringBuffer, so we can replace it with the result
03767       setLengthID = ( *jenv )->GetMethodID( jenv, sbufClass, "setLength", "(I)V" );
03768       ( *jenv )->CallVoidMethod( jenv, jarg1, setLengthID, (jint) 0 );
03769     }
03770   }
03771   plgdev(arg1);
03772   {
03773     if ( arg1 != NULL )
03774     {
03775       // Append the result to the empty StringBuffer
03776       jstring   newString      = ( *jenv )->NewStringUTF( jenv, arg1 );
03777       jclass    sbufClass      = ( *jenv )->GetObjectClass( jenv, jarg1 );
03778       jmethodID appendStringID = ( *jenv )->GetMethodID( jenv, sbufClass, "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;" );
03779       ( *jenv )->CallObjectMethod( jenv, jarg1, appendStringID, newString );
03780       
03781       // Clean up the string object, no longer needed
03782       free( arg1 );
03783       arg1 = NULL;
03784     }
03785   }
03786   
03787 }
03788 
03789 
03790 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgdidev(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jdoubleArray jarg3, jdoubleArray jarg4) {
03791   PLFLT *arg1 = (PLFLT *) 0 ;
03792   PLFLT *arg2 = (PLFLT *) 0 ;
03793   PLFLT *arg3 = (PLFLT *) 0 ;
03794   PLFLT *arg4 = (PLFLT *) 0 ;
03795   PLFLT temp1 ;
03796   PLFLT temp2 ;
03797   PLFLT temp3 ;
03798   PLFLT temp4 ;
03799   
03800   (void)jenv;
03801   (void)jcls;
03802   {
03803     if (!jarg1) {
03804       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03805       return ;
03806     }
03807     if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
03808       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03809       return ;
03810     }
03811     arg1 = &temp1; 
03812   }
03813   {
03814     if (!jarg2) {
03815       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03816       return ;
03817     }
03818     if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
03819       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03820       return ;
03821     }
03822     arg2 = &temp2; 
03823   }
03824   {
03825     if (!jarg3) {
03826       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03827       return ;
03828     }
03829     if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
03830       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03831       return ;
03832     }
03833     arg3 = &temp3; 
03834   }
03835   {
03836     if (!jarg4) {
03837       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03838       return ;
03839     }
03840     if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
03841       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03842       return ;
03843     }
03844     arg4 = &temp4; 
03845   }
03846   plgdidev(arg1,arg2,arg3,arg4);
03847   {
03848     jdouble jvalue = (jdouble)temp1;
03849     (*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);
03850   }
03851   {
03852     jdouble jvalue = (jdouble)temp2;
03853     (*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);
03854   }
03855   {
03856     jdouble jvalue = (jdouble)temp3;
03857     (*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);
03858   }
03859   {
03860     jdouble jvalue = (jdouble)temp4;
03861     (*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);
03862   }
03863   
03864   
03865   
03866   
03867 }
03868 
03869 
03870 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgdiori(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1) {
03871   PLFLT *arg1 = (PLFLT *) 0 ;
03872   PLFLT temp1 ;
03873   
03874   (void)jenv;
03875   (void)jcls;
03876   {
03877     if (!jarg1) {
03878       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03879       return ;
03880     }
03881     if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
03882       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03883       return ;
03884     }
03885     arg1 = &temp1; 
03886   }
03887   plgdiori(arg1);
03888   {
03889     jdouble jvalue = (jdouble)temp1;
03890     (*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);
03891   }
03892   
03893 }
03894 
03895 
03896 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgdiplt(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jdoubleArray jarg3, jdoubleArray jarg4) {
03897   PLFLT *arg1 = (PLFLT *) 0 ;
03898   PLFLT *arg2 = (PLFLT *) 0 ;
03899   PLFLT *arg3 = (PLFLT *) 0 ;
03900   PLFLT *arg4 = (PLFLT *) 0 ;
03901   PLFLT temp1 ;
03902   PLFLT temp2 ;
03903   PLFLT temp3 ;
03904   PLFLT temp4 ;
03905   
03906   (void)jenv;
03907   (void)jcls;
03908   {
03909     if (!jarg1) {
03910       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03911       return ;
03912     }
03913     if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
03914       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03915       return ;
03916     }
03917     arg1 = &temp1; 
03918   }
03919   {
03920     if (!jarg2) {
03921       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03922       return ;
03923     }
03924     if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
03925       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03926       return ;
03927     }
03928     arg2 = &temp2; 
03929   }
03930   {
03931     if (!jarg3) {
03932       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03933       return ;
03934     }
03935     if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
03936       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03937       return ;
03938     }
03939     arg3 = &temp3; 
03940   }
03941   {
03942     if (!jarg4) {
03943       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03944       return ;
03945     }
03946     if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
03947       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03948       return ;
03949     }
03950     arg4 = &temp4; 
03951   }
03952   plgdiplt(arg1,arg2,arg3,arg4);
03953   {
03954     jdouble jvalue = (jdouble)temp1;
03955     (*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);
03956   }
03957   {
03958     jdouble jvalue = (jdouble)temp2;
03959     (*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);
03960   }
03961   {
03962     jdouble jvalue = (jdouble)temp3;
03963     (*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);
03964   }
03965   {
03966     jdouble jvalue = (jdouble)temp4;
03967     (*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);
03968   }
03969   
03970   
03971   
03972   
03973 }
03974 
03975 
03976 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgfam(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2, jintArray jarg3) {
03977   PLINT *arg1 = (PLINT *) 0 ;
03978   PLINT *arg2 = (PLINT *) 0 ;
03979   PLINT *arg3 = (PLINT *) 0 ;
03980   PLINT temp1 ;
03981   PLINT temp2 ;
03982   PLINT temp3 ;
03983   
03984   (void)jenv;
03985   (void)jcls;
03986   {
03987     if (!jarg1) {
03988       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
03989       return ;
03990     }
03991     if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
03992       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
03993       return ;
03994     }
03995     arg1 = &temp1; 
03996   }
03997   {
03998     if (!jarg2) {
03999       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04000       return ;
04001     }
04002     if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
04003       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04004       return ;
04005     }
04006     arg2 = &temp2; 
04007   }
04008   {
04009     if (!jarg3) {
04010       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04011       return ;
04012     }
04013     if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
04014       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04015       return ;
04016     }
04017     arg3 = &temp3; 
04018   }
04019   plgfam(arg1,arg2,arg3);
04020   {
04021     jint jvalue = (jint)temp1;
04022     (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
04023   }
04024   {
04025     jint jvalue = (jint)temp2;
04026     (*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);
04027   }
04028   {
04029     jint jvalue = (jint)temp3;
04030     (*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);
04031   }
04032   
04033   
04034   
04035 }
04036 
04037 
04038 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgfci(JNIEnv *jenv, jclass jcls, jlongArray jarg1) {
04039   PLUNICODE *arg1 = (PLUNICODE *) 0 ;
04040   PLUNICODE temp1 ;
04041   
04042   (void)jenv;
04043   (void)jcls;
04044   {
04045     if (!jarg1) {
04046       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04047       return ;
04048     }
04049     if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
04050       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04051       return ;
04052     }
04053     arg1 = &temp1; 
04054   }
04055   plgfci(arg1);
04056   {
04057     jlong jvalue = (jlong)temp1;
04058     (*jenv)->SetLongArrayRegion(jenv, jarg1, 0, 1, &jvalue);
04059   }
04060   
04061 }
04062 
04063 
04064 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgfnam(JNIEnv *jenv, jclass jcls, jobject jarg1) {
04065   char *arg1 = (char *) 0 ;
04066   
04067   (void)jenv;
04068   (void)jcls;
04069   {
04070     arg1 = NULL;
04071     if ( jarg1 != NULL )
04072     {
04073       // Get the String from the StringBuffer
04074       jmethodID setLengthID;
04075       jclass    sbufClass = ( *jenv )->GetObjectClass( jenv, jarg1 );
04076       // Take a copy of the C string as the typemap is for a non const C string
04077       jmethodID capacityID = ( *jenv )->GetMethodID( jenv, sbufClass, "capacity", "()I" );
04078       jint      capacity   = ( *jenv )->CallIntMethod( jenv, jarg1, capacityID );
04079       arg1 = (char *) malloc( capacity + 1 );
04080       
04081       // Zero the original StringBuffer, so we can replace it with the result
04082       setLengthID = ( *jenv )->GetMethodID( jenv, sbufClass, "setLength", "(I)V" );
04083       ( *jenv )->CallVoidMethod( jenv, jarg1, setLengthID, (jint) 0 );
04084     }
04085   }
04086   plgfnam(arg1);
04087   {
04088     if ( arg1 != NULL )
04089     {
04090       // Append the result to the empty StringBuffer
04091       jstring   newString      = ( *jenv )->NewStringUTF( jenv, arg1 );
04092       jclass    sbufClass      = ( *jenv )->GetObjectClass( jenv, jarg1 );
04093       jmethodID appendStringID = ( *jenv )->GetMethodID( jenv, sbufClass, "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;" );
04094       ( *jenv )->CallObjectMethod( jenv, jarg1, appendStringID, newString );
04095       
04096       // Clean up the string object, no longer needed
04097       free( arg1 );
04098       arg1 = NULL;
04099     }
04100   }
04101   
04102 }
04103 
04104 
04105 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgfont(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2, jintArray jarg3) {
04106   PLINT *arg1 = (PLINT *) 0 ;
04107   PLINT *arg2 = (PLINT *) 0 ;
04108   PLINT *arg3 = (PLINT *) 0 ;
04109   PLINT temp1 ;
04110   PLINT temp2 ;
04111   PLINT temp3 ;
04112   
04113   (void)jenv;
04114   (void)jcls;
04115   {
04116     if (!jarg1) {
04117       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04118       return ;
04119     }
04120     if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
04121       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04122       return ;
04123     }
04124     arg1 = &temp1; 
04125   }
04126   {
04127     if (!jarg2) {
04128       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04129       return ;
04130     }
04131     if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
04132       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04133       return ;
04134     }
04135     arg2 = &temp2; 
04136   }
04137   {
04138     if (!jarg3) {
04139       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04140       return ;
04141     }
04142     if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
04143       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04144       return ;
04145     }
04146     arg3 = &temp3; 
04147   }
04148   plgfont(arg1,arg2,arg3);
04149   {
04150     jint jvalue = (jint)temp1;
04151     (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
04152   }
04153   {
04154     jint jvalue = (jint)temp2;
04155     (*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);
04156   }
04157   {
04158     jint jvalue = (jint)temp3;
04159     (*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);
04160   }
04161   
04162   
04163   
04164 }
04165 
04166 
04167 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plglevel(JNIEnv *jenv, jclass jcls, jintArray jarg1) {
04168   PLINT *arg1 = (PLINT *) 0 ;
04169   PLINT temp1 ;
04170   
04171   (void)jenv;
04172   (void)jcls;
04173   {
04174     if (!jarg1) {
04175       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04176       return ;
04177     }
04178     if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
04179       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04180       return ;
04181     }
04182     arg1 = &temp1; 
04183   }
04184   plglevel(arg1);
04185   {
04186     jint jvalue = (jint)temp1;
04187     (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
04188   }
04189   
04190 }
04191 
04192 
04193 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgpage(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jintArray jarg3, jintArray jarg4, jintArray jarg5, jintArray jarg6) {
04194   PLFLT *arg1 = (PLFLT *) 0 ;
04195   PLFLT *arg2 = (PLFLT *) 0 ;
04196   PLINT *arg3 = (PLINT *) 0 ;
04197   PLINT *arg4 = (PLINT *) 0 ;
04198   PLINT *arg5 = (PLINT *) 0 ;
04199   PLINT *arg6 = (PLINT *) 0 ;
04200   PLFLT temp1 ;
04201   PLFLT temp2 ;
04202   PLINT temp3 ;
04203   PLINT temp4 ;
04204   PLINT temp5 ;
04205   PLINT temp6 ;
04206   
04207   (void)jenv;
04208   (void)jcls;
04209   {
04210     if (!jarg1) {
04211       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04212       return ;
04213     }
04214     if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
04215       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04216       return ;
04217     }
04218     arg1 = &temp1; 
04219   }
04220   {
04221     if (!jarg2) {
04222       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04223       return ;
04224     }
04225     if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
04226       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04227       return ;
04228     }
04229     arg2 = &temp2; 
04230   }
04231   {
04232     if (!jarg3) {
04233       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04234       return ;
04235     }
04236     if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
04237       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04238       return ;
04239     }
04240     arg3 = &temp3; 
04241   }
04242   {
04243     if (!jarg4) {
04244       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04245       return ;
04246     }
04247     if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
04248       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04249       return ;
04250     }
04251     arg4 = &temp4; 
04252   }
04253   {
04254     if (!jarg5) {
04255       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04256       return ;
04257     }
04258     if ((*jenv)->GetArrayLength(jenv, jarg5) == 0) {
04259       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04260       return ;
04261     }
04262     arg5 = &temp5; 
04263   }
04264   {
04265     if (!jarg6) {
04266       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04267       return ;
04268     }
04269     if ((*jenv)->GetArrayLength(jenv, jarg6) == 0) {
04270       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04271       return ;
04272     }
04273     arg6 = &temp6; 
04274   }
04275   plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
04276   {
04277     jdouble jvalue = (jdouble)temp1;
04278     (*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);
04279   }
04280   {
04281     jdouble jvalue = (jdouble)temp2;
04282     (*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);
04283   }
04284   {
04285     jint jvalue = (jint)temp3;
04286     (*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);
04287   }
04288   {
04289     jint jvalue = (jint)temp4;
04290     (*jenv)->SetIntArrayRegion(jenv, jarg4, 0, 1, &jvalue);
04291   }
04292   {
04293     jint jvalue = (jint)temp5;
04294     (*jenv)->SetIntArrayRegion(jenv, jarg5, 0, 1, &jvalue);
04295   }
04296   {
04297     jint jvalue = (jint)temp6;
04298     (*jenv)->SetIntArrayRegion(jenv, jarg6, 0, 1, &jvalue);
04299   }
04300   
04301   
04302   
04303   
04304   
04305   
04306 }
04307 
04308 
04309 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgra(JNIEnv *jenv, jclass jcls) {
04310   (void)jenv;
04311   (void)jcls;
04312   plgra();
04313 }
04314 
04315 
04316 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgriddata(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jdoubleArray jarg3, jdoubleArray jarg5, jdoubleArray jarg7, jobjectArray jarg9, jint jarg10, jdouble jarg11) {
04317   PLFLT *arg1 = (PLFLT *) 0 ;
04318   PLFLT *arg2 = (PLFLT *) 0 ;
04319   PLFLT *arg3 = (PLFLT *) 0 ;
04320   PLINT arg4 ;
04321   PLFLT *arg5 = (PLFLT *) 0 ;
04322   PLINT arg6 ;
04323   PLFLT *arg7 = (PLFLT *) 0 ;
04324   PLINT arg8 ;
04325   PLFLT **arg9 = (PLFLT **) 0 ;
04326   PLINT arg10 ;
04327   PLFLT arg11 ;
04328   
04329   (void)jenv;
04330   (void)jcls;
04331   {
04332     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
04333     Alen = ( *jenv )->GetArrayLength( jenv, jarg1 );
04334     setup_array_1d_d( &arg1, jxdata, Alen );
04335     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
04336   }
04337   {
04338     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg2, 0 );
04339     if ( ( *jenv )->GetArrayLength( jenv, jarg2 ) != Alen )
04340     {
04341       printf( "Vectors must be same length.\n" );
04342       return;
04343     }
04344     setup_array_1d_d( &arg2, jydata, Alen );
04345     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );
04346   }
04347   {
04348     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
04349     arg4 = ( *jenv )->GetArrayLength( jenv, jarg3 );
04350     if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
04351     {
04352       printf( "Vectors must be same length.\n" );
04353       return;
04354     }
04355     setup_array_1d_d( &arg3, jydata, Alen );
04356     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
04357   }
04358   {
04359     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg5, 0 );
04360     Xlen = ( *jenv )->GetArrayLength( jenv, jarg5 );
04361     arg6   = Xlen;
04362     setup_array_1d_d( &arg5, jxdata, Xlen );
04363     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg5, jxdata, 0 );
04364   }
04365   {
04366     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg7, 0 );
04367     Ylen = ( *jenv )->GetArrayLength( jenv, jarg7 );
04368     arg8   = Ylen;
04369     setup_array_1d_d( &arg7, jydata, Ylen );
04370     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg7, jydata, 0 );
04371   }
04372   {
04373     jobject ai;
04374     PLFLT   **ptr;
04375     int     nx = ( *jenv )->GetArrayLength( jenv, jarg9 );
04376     int     ny = -1;
04377     int     i;
04378     
04379     ( *jenv )->EnsureLocalCapacity( jenv, nx );
04380     
04381     for ( i = 0; i < nx; i++ )
04382     {
04383       ai = ( *jenv )->GetObjectArrayElement( jenv, jarg9, i );
04384       
04385       if ( ny == -1 )
04386       ny = ( *jenv )->GetArrayLength( jenv, ai );
04387       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai ) )
04388       {
04389         printf( "Misshapen a array.\n" );
04390         return;
04391       }
04392     }
04393     
04394     if ( nx != Xlen || ny != Ylen )
04395     {
04396       printf( "Vectors must match matrix.\n" );
04397       return;
04398     }
04399     
04400     ptr    = (PLFLT **) malloc( nx * sizeof ( PLFLT * ) );
04401     ptr[0] = (PLFLT *) malloc( nx * ny * sizeof ( PLFLT ) );
04402     for ( i = 0; i < nx; i++ )
04403     {
04404       ptr[i] = ptr[0] + i * ny;
04405     }
04406     
04407     arg9 = ptr;
04408   }
04409   arg10 = (PLINT)jarg10; 
04410   arg11 = (PLFLT)jarg11; 
04411   plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
04412   {
04413     jdouble  **adat;
04414     jobject *ai;
04415     PLFLT   **ptr;
04416     int     i, j;
04417     int     nx = ( *jenv )->GetArrayLength( jenv, jarg9 );
04418     int     ny = -1;
04419     
04420     ptr = arg9;
04421     
04422     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
04423     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
04424     
04425     for ( i = 0; i < nx; i++ )
04426     {
04427       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg9, i );
04428       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
04429       
04430       if ( ny == -1 )
04431       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
04432     }
04433     for ( i = 0; i < nx; i++ )
04434     {
04435       for ( j = 0; j < ny; j++ )
04436       {
04437         adat[i][j] = ptr[i][j];
04438       }
04439       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
04440       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
04441     }
04442     
04443     free( adat );
04444     free( ai );
04445   }
04446   {
04447     free( arg1 );
04448   }
04449   {
04450     free( arg2 );
04451   }
04452   {
04453     free( arg3 );
04454   }
04455   {
04456     free( arg5 );
04457   }
04458   {
04459     free( arg7 );
04460   }
04461   {
04462     free( arg9[0] );
04463     free( arg9 );
04464   }
04465 }
04466 
04467 
04468 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgspa(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jdoubleArray jarg3, jdoubleArray jarg4) {
04469   PLFLT *arg1 = (PLFLT *) 0 ;
04470   PLFLT *arg2 = (PLFLT *) 0 ;
04471   PLFLT *arg3 = (PLFLT *) 0 ;
04472   PLFLT *arg4 = (PLFLT *) 0 ;
04473   PLFLT temp1 ;
04474   PLFLT temp2 ;
04475   PLFLT temp3 ;
04476   PLFLT temp4 ;
04477   
04478   (void)jenv;
04479   (void)jcls;
04480   {
04481     if (!jarg1) {
04482       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04483       return ;
04484     }
04485     if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
04486       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04487       return ;
04488     }
04489     arg1 = &temp1; 
04490   }
04491   {
04492     if (!jarg2) {
04493       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04494       return ;
04495     }
04496     if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
04497       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04498       return ;
04499     }
04500     arg2 = &temp2; 
04501   }
04502   {
04503     if (!jarg3) {
04504       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04505       return ;
04506     }
04507     if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
04508       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04509       return ;
04510     }
04511     arg3 = &temp3; 
04512   }
04513   {
04514     if (!jarg4) {
04515       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04516       return ;
04517     }
04518     if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
04519       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04520       return ;
04521     }
04522     arg4 = &temp4; 
04523   }
04524   plgspa(arg1,arg2,arg3,arg4);
04525   {
04526     jdouble jvalue = (jdouble)temp1;
04527     (*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);
04528   }
04529   {
04530     jdouble jvalue = (jdouble)temp2;
04531     (*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);
04532   }
04533   {
04534     jdouble jvalue = (jdouble)temp3;
04535     (*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);
04536   }
04537   {
04538     jdouble jvalue = (jdouble)temp4;
04539     (*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);
04540   }
04541   
04542   
04543   
04544   
04545 }
04546 
04547 
04548 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgstrm(JNIEnv *jenv, jclass jcls, jintArray jarg1) {
04549   PLINT *arg1 = (PLINT *) 0 ;
04550   PLINT temp1 ;
04551   
04552   (void)jenv;
04553   (void)jcls;
04554   {
04555     if (!jarg1) {
04556       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04557       return ;
04558     }
04559     if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
04560       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04561       return ;
04562     }
04563     arg1 = &temp1; 
04564   }
04565   plgstrm(arg1);
04566   {
04567     jint jvalue = (jint)temp1;
04568     (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
04569   }
04570   
04571 }
04572 
04573 
04574 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgver(JNIEnv *jenv, jclass jcls, jobject jarg1) {
04575   char *arg1 = (char *) 0 ;
04576   
04577   (void)jenv;
04578   (void)jcls;
04579   {
04580     arg1 = NULL;
04581     if ( jarg1 != NULL )
04582     {
04583       // Get the String from the StringBuffer
04584       jmethodID setLengthID;
04585       jclass    sbufClass = ( *jenv )->GetObjectClass( jenv, jarg1 );
04586       // Take a copy of the C string as the typemap is for a non const C string
04587       jmethodID capacityID = ( *jenv )->GetMethodID( jenv, sbufClass, "capacity", "()I" );
04588       jint      capacity   = ( *jenv )->CallIntMethod( jenv, jarg1, capacityID );
04589       arg1 = (char *) malloc( capacity + 1 );
04590       
04591       // Zero the original StringBuffer, so we can replace it with the result
04592       setLengthID = ( *jenv )->GetMethodID( jenv, sbufClass, "setLength", "(I)V" );
04593       ( *jenv )->CallVoidMethod( jenv, jarg1, setLengthID, (jint) 0 );
04594     }
04595   }
04596   plgver(arg1);
04597   {
04598     if ( arg1 != NULL )
04599     {
04600       // Append the result to the empty StringBuffer
04601       jstring   newString      = ( *jenv )->NewStringUTF( jenv, arg1 );
04602       jclass    sbufClass      = ( *jenv )->GetObjectClass( jenv, jarg1 );
04603       jmethodID appendStringID = ( *jenv )->GetMethodID( jenv, sbufClass, "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;" );
04604       ( *jenv )->CallObjectMethod( jenv, jarg1, appendStringID, newString );
04605       
04606       // Clean up the string object, no longer needed
04607       free( arg1 );
04608       arg1 = NULL;
04609     }
04610   }
04611   
04612 }
04613 
04614 
04615 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgvpd(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jdoubleArray jarg3, jdoubleArray jarg4) {
04616   PLFLT *arg1 = (PLFLT *) 0 ;
04617   PLFLT *arg2 = (PLFLT *) 0 ;
04618   PLFLT *arg3 = (PLFLT *) 0 ;
04619   PLFLT *arg4 = (PLFLT *) 0 ;
04620   PLFLT temp1 ;
04621   PLFLT temp2 ;
04622   PLFLT temp3 ;
04623   PLFLT temp4 ;
04624   
04625   (void)jenv;
04626   (void)jcls;
04627   {
04628     if (!jarg1) {
04629       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04630       return ;
04631     }
04632     if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
04633       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04634       return ;
04635     }
04636     arg1 = &temp1; 
04637   }
04638   {
04639     if (!jarg2) {
04640       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04641       return ;
04642     }
04643     if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
04644       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04645       return ;
04646     }
04647     arg2 = &temp2; 
04648   }
04649   {
04650     if (!jarg3) {
04651       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04652       return ;
04653     }
04654     if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
04655       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04656       return ;
04657     }
04658     arg3 = &temp3; 
04659   }
04660   {
04661     if (!jarg4) {
04662       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04663       return ;
04664     }
04665     if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
04666       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04667       return ;
04668     }
04669     arg4 = &temp4; 
04670   }
04671   plgvpd(arg1,arg2,arg3,arg4);
04672   {
04673     jdouble jvalue = (jdouble)temp1;
04674     (*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);
04675   }
04676   {
04677     jdouble jvalue = (jdouble)temp2;
04678     (*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);
04679   }
04680   {
04681     jdouble jvalue = (jdouble)temp3;
04682     (*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);
04683   }
04684   {
04685     jdouble jvalue = (jdouble)temp4;
04686     (*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);
04687   }
04688   
04689   
04690   
04691   
04692 }
04693 
04694 
04695 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgvpw(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jdoubleArray jarg3, jdoubleArray jarg4) {
04696   PLFLT *arg1 = (PLFLT *) 0 ;
04697   PLFLT *arg2 = (PLFLT *) 0 ;
04698   PLFLT *arg3 = (PLFLT *) 0 ;
04699   PLFLT *arg4 = (PLFLT *) 0 ;
04700   PLFLT temp1 ;
04701   PLFLT temp2 ;
04702   PLFLT temp3 ;
04703   PLFLT temp4 ;
04704   
04705   (void)jenv;
04706   (void)jcls;
04707   {
04708     if (!jarg1) {
04709       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04710       return ;
04711     }
04712     if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
04713       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04714       return ;
04715     }
04716     arg1 = &temp1; 
04717   }
04718   {
04719     if (!jarg2) {
04720       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04721       return ;
04722     }
04723     if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
04724       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04725       return ;
04726     }
04727     arg2 = &temp2; 
04728   }
04729   {
04730     if (!jarg3) {
04731       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04732       return ;
04733     }
04734     if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
04735       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04736       return ;
04737     }
04738     arg3 = &temp3; 
04739   }
04740   {
04741     if (!jarg4) {
04742       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04743       return ;
04744     }
04745     if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
04746       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04747       return ;
04748     }
04749     arg4 = &temp4; 
04750   }
04751   plgvpw(arg1,arg2,arg3,arg4);
04752   {
04753     jdouble jvalue = (jdouble)temp1;
04754     (*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);
04755   }
04756   {
04757     jdouble jvalue = (jdouble)temp2;
04758     (*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);
04759   }
04760   {
04761     jdouble jvalue = (jdouble)temp3;
04762     (*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);
04763   }
04764   {
04765     jdouble jvalue = (jdouble)temp4;
04766     (*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);
04767   }
04768   
04769   
04770   
04771   
04772 }
04773 
04774 
04775 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgxax(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2) {
04776   PLINT *arg1 = (PLINT *) 0 ;
04777   PLINT *arg2 = (PLINT *) 0 ;
04778   PLINT temp1 ;
04779   PLINT temp2 ;
04780   
04781   (void)jenv;
04782   (void)jcls;
04783   {
04784     if (!jarg1) {
04785       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04786       return ;
04787     }
04788     if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
04789       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04790       return ;
04791     }
04792     arg1 = &temp1; 
04793   }
04794   {
04795     if (!jarg2) {
04796       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04797       return ;
04798     }
04799     if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
04800       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04801       return ;
04802     }
04803     arg2 = &temp2; 
04804   }
04805   plgxax(arg1,arg2);
04806   {
04807     jint jvalue = (jint)temp1;
04808     (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
04809   }
04810   {
04811     jint jvalue = (jint)temp2;
04812     (*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);
04813   }
04814   
04815   
04816 }
04817 
04818 
04819 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgyax(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2) {
04820   PLINT *arg1 = (PLINT *) 0 ;
04821   PLINT *arg2 = (PLINT *) 0 ;
04822   PLINT temp1 ;
04823   PLINT temp2 ;
04824   
04825   (void)jenv;
04826   (void)jcls;
04827   {
04828     if (!jarg1) {
04829       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04830       return ;
04831     }
04832     if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
04833       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04834       return ;
04835     }
04836     arg1 = &temp1; 
04837   }
04838   {
04839     if (!jarg2) {
04840       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04841       return ;
04842     }
04843     if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
04844       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04845       return ;
04846     }
04847     arg2 = &temp2; 
04848   }
04849   plgyax(arg1,arg2);
04850   {
04851     jint jvalue = (jint)temp1;
04852     (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
04853   }
04854   {
04855     jint jvalue = (jint)temp2;
04856     (*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);
04857   }
04858   
04859   
04860 }
04861 
04862 
04863 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgzax(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2) {
04864   PLINT *arg1 = (PLINT *) 0 ;
04865   PLINT *arg2 = (PLINT *) 0 ;
04866   PLINT temp1 ;
04867   PLINT temp2 ;
04868   
04869   (void)jenv;
04870   (void)jcls;
04871   {
04872     if (!jarg1) {
04873       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04874       return ;
04875     }
04876     if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
04877       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04878       return ;
04879     }
04880     arg1 = &temp1; 
04881   }
04882   {
04883     if (!jarg2) {
04884       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04885       return ;
04886     }
04887     if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
04888       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04889       return ;
04890     }
04891     arg2 = &temp2; 
04892   }
04893   plgzax(arg1,arg2);
04894   {
04895     jint jvalue = (jint)temp1;
04896     (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
04897   }
04898   {
04899     jint jvalue = (jint)temp2;
04900     (*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);
04901   }
04902   
04903   
04904 }
04905 
04906 
04907 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plhist(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdouble jarg3, jdouble jarg4, jint jarg5, jint jarg6) {
04908   PLINT arg1 ;
04909   PLFLT *arg2 = (PLFLT *) 0 ;
04910   PLFLT arg3 ;
04911   PLFLT arg4 ;
04912   PLINT arg5 ;
04913   PLINT arg6 ;
04914   
04915   (void)jenv;
04916   (void)jcls;
04917   {
04918     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
04919     arg1   = ( *jenv )->GetArrayLength( jenv, jarg1 );
04920     Alen = arg1;
04921     setup_array_1d_d( &arg2, jxdata, Alen );
04922     // Could find no easy way to do this as part of freearg so I modified
04923     // the previous function so it ALWAYS mallocs and copies so that
04924     // the java array can be released immediately.
04925     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
04926   }
04927   arg3 = (PLFLT)jarg3; 
04928   arg4 = (PLFLT)jarg4; 
04929   arg5 = (PLINT)jarg5; 
04930   arg6 = (PLINT)jarg6; 
04931   plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
04932   {
04933     free( arg2 );
04934   }
04935 }
04936 
04937 
04938 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plhlsrgb(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdoubleArray jarg4, jdoubleArray jarg5, jdoubleArray jarg6) {
04939   PLFLT arg1 ;
04940   PLFLT arg2 ;
04941   PLFLT arg3 ;
04942   PLFLT *arg4 = (PLFLT *) 0 ;
04943   PLFLT *arg5 = (PLFLT *) 0 ;
04944   PLFLT *arg6 = (PLFLT *) 0 ;
04945   PLFLT temp4 ;
04946   PLFLT temp5 ;
04947   PLFLT temp6 ;
04948   
04949   (void)jenv;
04950   (void)jcls;
04951   arg1 = (PLFLT)jarg1; 
04952   arg2 = (PLFLT)jarg2; 
04953   arg3 = (PLFLT)jarg3; 
04954   {
04955     if (!jarg4) {
04956       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04957       return ;
04958     }
04959     if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
04960       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04961       return ;
04962     }
04963     arg4 = &temp4; 
04964   }
04965   {
04966     if (!jarg5) {
04967       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04968       return ;
04969     }
04970     if ((*jenv)->GetArrayLength(jenv, jarg5) == 0) {
04971       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04972       return ;
04973     }
04974     arg5 = &temp5; 
04975   }
04976   {
04977     if (!jarg6) {
04978       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
04979       return ;
04980     }
04981     if ((*jenv)->GetArrayLength(jenv, jarg6) == 0) {
04982       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
04983       return ;
04984     }
04985     arg6 = &temp6; 
04986   }
04987   plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
04988   {
04989     jdouble jvalue = (jdouble)temp4;
04990     (*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);
04991   }
04992   {
04993     jdouble jvalue = (jdouble)temp5;
04994     (*jenv)->SetDoubleArrayRegion(jenv, jarg5, 0, 1, &jvalue);
04995   }
04996   {
04997     jdouble jvalue = (jdouble)temp6;
04998     (*jenv)->SetDoubleArrayRegion(jenv, jarg6, 0, 1, &jvalue);
04999   }
05000   
05001   
05002   
05003 }
05004 
05005 
05006 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plinit(JNIEnv *jenv, jclass jcls) {
05007   (void)jenv;
05008   (void)jcls;
05009   plinit();
05010 }
05011 
05012 
05013 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pljoin(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4) {
05014   PLFLT arg1 ;
05015   PLFLT arg2 ;
05016   PLFLT arg3 ;
05017   PLFLT arg4 ;
05018   
05019   (void)jenv;
05020   (void)jcls;
05021   arg1 = (PLFLT)jarg1; 
05022   arg2 = (PLFLT)jarg2; 
05023   arg3 = (PLFLT)jarg3; 
05024   arg4 = (PLFLT)jarg4; 
05025   pljoin(arg1,arg2,arg3,arg4);
05026 }
05027 
05028 
05029 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pllab(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2, jstring jarg3) {
05030   char *arg1 = (char *) 0 ;
05031   char *arg2 = (char *) 0 ;
05032   char *arg3 = (char *) 0 ;
05033   
05034   (void)jenv;
05035   (void)jcls;
05036   arg1 = 0;
05037   if (jarg1) {
05038     arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
05039     if (!arg1) return ;
05040   }
05041   arg2 = 0;
05042   if (jarg2) {
05043     arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);
05044     if (!arg2) return ;
05045   }
05046   arg3 = 0;
05047   if (jarg3) {
05048     arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0);
05049     if (!arg3) return ;
05050   }
05051   pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
05052   if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
05053   if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2);
05054   if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3);
05055 }
05056 
05057 
05058 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pllegend(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jint jarg3, jint jarg4, jdouble jarg5, jdouble jarg6, jdouble jarg7, jint jarg8, jint jarg9, jint jarg10, jint jarg11, jint jarg12, jintArray jarg13, jdouble jarg15, jdouble jarg16, jdouble jarg17, jdouble jarg18, jintArray jarg19, jobjectArray jarg20, jintArray jarg21, jintArray jarg22, jdoubleArray jarg23, jintArray jarg24, jintArray jarg25, jintArray jarg26, jintArray jarg27, jintArray jarg28, jdoubleArray jarg29, jintArray jarg30, jobjectArray jarg31) {
05059   PLFLT *arg1 = (PLFLT *) 0 ;
05060   PLFLT *arg2 = (PLFLT *) 0 ;
05061   PLINT arg3 ;
05062   PLINT arg4 ;
05063   PLFLT arg5 ;
05064   PLFLT arg6 ;
05065   PLFLT arg7 ;
05066   PLINT arg8 ;
05067   PLINT arg9 ;
05068   PLINT arg10 ;
05069   PLINT arg11 ;
05070   PLINT arg12 ;
05071   PLINT arg13 ;
05072   PLINT *arg14 = (PLINT *) 0 ;
05073   PLFLT arg15 ;
05074   PLFLT arg16 ;
05075   PLFLT arg17 ;
05076   PLFLT arg18 ;
05077   PLINT *arg19 = (PLINT *) 0 ;
05078   char **arg20 = (char **) 0 ;
05079   PLINT *arg21 = (PLINT *) 0 ;
05080   PLINT *arg22 = (PLINT *) 0 ;
05081   PLFLT *arg23 = (PLFLT *) 0 ;
05082   PLINT *arg24 = (PLINT *) 0 ;
05083   PLINT *arg25 = (PLINT *) 0 ;
05084   PLINT *arg26 = (PLINT *) 0 ;
05085   PLINT *arg27 = (PLINT *) 0 ;
05086   PLINT *arg28 = (PLINT *) 0 ;
05087   PLFLT *arg29 = (PLFLT *) 0 ;
05088   PLINT *arg30 = (PLINT *) 0 ;
05089   char **arg31 = (char **) 0 ;
05090   PLFLT temp1 ;
05091   PLFLT temp2 ;
05092   
05093   (void)jenv;
05094   (void)jcls;
05095   {
05096     if (!jarg1) {
05097       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
05098       return ;
05099     }
05100     if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
05101       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
05102       return ;
05103     }
05104     arg1 = &temp1; 
05105   }
05106   {
05107     if (!jarg2) {
05108       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
05109       return ;
05110     }
05111     if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
05112       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
05113       return ;
05114     }
05115     arg2 = &temp2; 
05116   }
05117   arg3 = (PLINT)jarg3; 
05118   arg4 = (PLINT)jarg4; 
05119   arg5 = (PLFLT)jarg5; 
05120   arg6 = (PLFLT)jarg6; 
05121   arg7 = (PLFLT)jarg7; 
05122   arg8 = (PLINT)jarg8; 
05123   arg9 = (PLINT)jarg9; 
05124   arg10 = (PLINT)jarg10; 
05125   arg11 = (PLINT)jarg11; 
05126   arg12 = (PLINT)jarg12; 
05127   {
05128     jint *jxdata = ( *jenv )->GetIntArrayElements( jenv, jarg13, 0 );
05129     arg13   = ( *jenv )->GetArrayLength( jenv, jarg13 );
05130     Alen = arg13;
05131     setup_array_1d_i( &arg14, jxdata, Alen );
05132     // Could find no easy way to do this as part of freearg so I modified
05133     // the previous function so it ALWAYS mallocs and copies so that
05134     // the java array can be released immediately.
05135     ( *jenv )->ReleaseIntArrayElements( jenv, jarg13, jxdata, 0 );
05136   }
05137   arg15 = (PLFLT)jarg15; 
05138   arg16 = (PLFLT)jarg16; 
05139   arg17 = (PLFLT)jarg17; 
05140   arg18 = (PLFLT)jarg18; 
05141   {
05142     jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg19, 0 );
05143     if ( ( *jenv )->GetArrayLength( jenv, jarg19 ) != Alen )
05144     {
05145       printf( "Vectors must be same length.\n" );
05146       return;
05147     }
05148     setup_array_1d_i( &arg19, jydata, Alen );
05149     ( *jenv )->ReleaseIntArrayElements( jenv, jarg19, jydata, 0 );
05150   }
05151   {
05152     int i = 0;
05153     if ( jarg20 != NULL )
05154     {
05155       int size = ( *jenv )->GetArrayLength( jenv, jarg20 );
05156       if ( size != Alen )
05157       {
05158         printf( "Arrays must be the same length\n" );
05159         return;
05160       }
05161       arg20 = (char **) malloc( Alen * sizeof ( char * ) );
05162       // make a copy of each string
05163       for ( i = 0; i < Alen; i++ )
05164       {
05165         jstring    j_string   = (jstring) ( *jenv )->GetObjectArrayElement( jenv, jarg20, i );
05166         const char * c_string = (char *) ( *jenv )->GetStringUTFChars( jenv, j_string, 0 );
05167         arg20[i] = malloc( ( strlen( c_string ) + 1 ) * sizeof ( const char * ) );
05168         strcpy( arg20[i], c_string );
05169         ( *jenv )->ReleaseStringUTFChars( jenv, j_string, c_string );
05170         ( *jenv )->DeleteLocalRef( jenv, j_string );
05171       }
05172     }
05173     else
05174     {
05175       arg20 = NULL;
05176     }
05177   }
05178   {
05179     if ( jarg21 != NULL )
05180     {
05181       jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg21, 0 );
05182       if ( ( *jenv )->GetArrayLength( jenv, jarg21 ) != Alen )
05183       {
05184         printf( "Vectors must be same length.\n" );
05185         return;
05186       }
05187       setup_array_1d_i( &arg21, jydata, Alen );
05188       ( *jenv )->ReleaseIntArrayElements( jenv, jarg21, jydata, 0 );
05189     }
05190     else
05191     {
05192       arg21 == NULL;
05193     }
05194   }
05195   {
05196     if ( jarg22 != NULL )
05197     {
05198       jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg22, 0 );
05199       if ( ( *jenv )->GetArrayLength( jenv, jarg22 ) != Alen )
05200       {
05201         printf( "Vectors must be same length.\n" );
05202         return;
05203       }
05204       setup_array_1d_i( &arg22, jydata, Alen );
05205       ( *jenv )->ReleaseIntArrayElements( jenv, jarg22, jydata, 0 );
05206     }
05207     else
05208     {
05209       arg22 == NULL;
05210     }
05211   }
05212   {
05213     if ( jarg23 != NULL )
05214     {
05215       jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg23, 0 );
05216       if ( ( *jenv )->GetArrayLength( jenv, jarg23 ) != Alen )
05217       {
05218         printf( "Vectors must be same length.\n" );
05219         return;
05220       }
05221       setup_array_1d_d( &arg23, jydata, Alen );
05222       ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg23, jydata, 0 );
05223     }
05224     else
05225     {
05226       arg23 = NULL;
05227     }
05228   }
05229   {
05230     if ( jarg24 != NULL )
05231     {
05232       jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg24, 0 );
05233       if ( ( *jenv )->GetArrayLength( jenv, jarg24 ) != Alen )
05234       {
05235         printf( "Vectors must be same length.\n" );
05236         return;
05237       }
05238       setup_array_1d_i( &arg24, jydata, Alen );
05239       ( *jenv )->ReleaseIntArrayElements( jenv, jarg24, jydata, 0 );
05240     }
05241     else
05242     {
05243       arg24 == NULL;
05244     }
05245   }
05246   {
05247     if ( jarg25 != NULL )
05248     {
05249       jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg25, 0 );
05250       if ( ( *jenv )->GetArrayLength( jenv, jarg25 ) != Alen )
05251       {
05252         printf( "Vectors must be same length.\n" );
05253         return;
05254       }
05255       setup_array_1d_i( &arg25, jydata, Alen );
05256       ( *jenv )->ReleaseIntArrayElements( jenv, jarg25, jydata, 0 );
05257     }
05258     else
05259     {
05260       arg25 == NULL;
05261     }
05262   }
05263   {
05264     if ( jarg26 != NULL )
05265     {
05266       jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg26, 0 );
05267       if ( ( *jenv )->GetArrayLength( jenv, jarg26 ) != Alen )
05268       {
05269         printf( "Vectors must be same length.\n" );
05270         return;
05271       }
05272       setup_array_1d_i( &arg26, jydata, Alen );
05273       ( *jenv )->ReleaseIntArrayElements( jenv, jarg26, jydata, 0 );
05274     }
05275     else
05276     {
05277       arg26 == NULL;
05278     }
05279   }
05280   {
05281     if ( jarg27 != NULL )
05282     {
05283       jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg27, 0 );
05284       if ( ( *jenv )->GetArrayLength( jenv, jarg27 ) != Alen )
05285       {
05286         printf( "Vectors must be same length.\n" );
05287         return;
05288       }
05289       setup_array_1d_i( &arg27, jydata, Alen );
05290       ( *jenv )->ReleaseIntArrayElements( jenv, jarg27, jydata, 0 );
05291     }
05292     else
05293     {
05294       arg27 == NULL;
05295     }
05296   }
05297   {
05298     if ( jarg28 != NULL )
05299     {
05300       jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg28, 0 );
05301       if ( ( *jenv )->GetArrayLength( jenv, jarg28 ) != Alen )
05302       {
05303         printf( "Vectors must be same length.\n" );
05304         return;
05305       }
05306       setup_array_1d_i( &arg28, jydata, Alen );
05307       ( *jenv )->ReleaseIntArrayElements( jenv, jarg28, jydata, 0 );
05308     }
05309     else
05310     {
05311       arg28 == NULL;
05312     }
05313   }
05314   {
05315     if ( jarg29 != NULL )
05316     {
05317       jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg29, 0 );
05318       if ( ( *jenv )->GetArrayLength( jenv, jarg29 ) != Alen )
05319       {
05320         printf( "Vectors must be same length.\n" );
05321         return;
05322       }
05323       setup_array_1d_d( &arg29, jydata, Alen );
05324       ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg29, jydata, 0 );
05325     }
05326     else
05327     {
05328       arg29 = NULL;
05329     }
05330   }
05331   {
05332     if ( jarg30 != NULL )
05333     {
05334       jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg30, 0 );
05335       if ( ( *jenv )->GetArrayLength( jenv, jarg30 ) != Alen )
05336       {
05337         printf( "Vectors must be same length.\n" );
05338         return;
05339       }
05340       setup_array_1d_i( &arg30, jydata, Alen );
05341       ( *jenv )->ReleaseIntArrayElements( jenv, jarg30, jydata, 0 );
05342     }
05343     else
05344     {
05345       arg30 == NULL;
05346     }
05347   }
05348   {
05349     int i = 0;
05350     if ( jarg31 != NULL )
05351     {
05352       int size = ( *jenv )->GetArrayLength( jenv, jarg31 );
05353       if ( size != Alen )
05354       {
05355         printf( "Arrays must be the same length\n" );
05356         return;
05357       }
05358       arg31 = (char **) malloc( Alen * sizeof ( char * ) );
05359       // make a copy of each string
05360       for ( i = 0; i < Alen; i++ )
05361       {
05362         jstring    j_string   = (jstring) ( *jenv )->GetObjectArrayElement( jenv, jarg31, i );
05363         const char * c_string = (char *) ( *jenv )->GetStringUTFChars( jenv, j_string, 0 );
05364         arg31[i] = malloc( ( strlen( c_string ) + 1 ) * sizeof ( const char * ) );
05365         strcpy( arg31[i], c_string );
05366         ( *jenv )->ReleaseStringUTFChars( jenv, j_string, c_string );
05367         ( *jenv )->DeleteLocalRef( jenv, j_string );
05368       }
05369     }
05370     else
05371     {
05372       arg31 = NULL;
05373     }
05374   }
05375   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,(int const *)arg24,(int const *)arg25,(int const *)arg26,(int const *)arg27,(int const *)arg28,(double const *)arg29,(int const *)arg30,(char const **)arg31);
05376   {
05377     jdouble jvalue = (jdouble)temp1;
05378     (*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);
05379   }
05380   {
05381     jdouble jvalue = (jdouble)temp2;
05382     (*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);
05383   }
05384   
05385   
05386   {
05387     free( arg14 );
05388   }
05389   {
05390     free( arg19 );
05391   }
05392   {
05393     int i;
05394     if ( arg20 != NULL )
05395     {
05396       for ( i = 0; i < Alen; i++ )
05397       free( arg20[i] );
05398       free( arg20 );
05399     }
05400   }
05401   {
05402     if ( arg21 != NULL )
05403     free( arg21 );
05404   }
05405   {
05406     if ( arg22 != NULL )
05407     free( arg22 );
05408   }
05409   {
05410     if ( arg23 != NULL )
05411     free( arg23 );
05412   }
05413   {
05414     if ( arg24 != NULL )
05415     free( arg24 );
05416   }
05417   {
05418     if ( arg25 != NULL )
05419     free( arg25 );
05420   }
05421   {
05422     if ( arg26 != NULL )
05423     free( arg26 );
05424   }
05425   {
05426     if ( arg27 != NULL )
05427     free( arg27 );
05428   }
05429   {
05430     if ( arg28 != NULL )
05431     free( arg28 );
05432   }
05433   {
05434     if ( arg29 != NULL )
05435     free( arg29 );
05436   }
05437   {
05438     if ( arg30 != NULL )
05439     free( arg30 );
05440   }
05441   {
05442     int i;
05443     if ( arg31 != NULL )
05444     {
05445       for ( i = 0; i < Alen; i++ )
05446       free( arg31[i] );
05447       free( arg31 );
05448     }
05449   }
05450 }
05451 
05452 
05453 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pllightsource(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3) {
05454   PLFLT arg1 ;
05455   PLFLT arg2 ;
05456   PLFLT arg3 ;
05457   
05458   (void)jenv;
05459   (void)jcls;
05460   arg1 = (PLFLT)jarg1; 
05461   arg2 = (PLFLT)jarg2; 
05462   arg3 = (PLFLT)jarg3; 
05463   pllightsource(arg1,arg2,arg3);
05464 }
05465 
05466 
05467 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plline(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3) {
05468   PLINT arg1 ;
05469   PLFLT *arg2 = (PLFLT *) 0 ;
05470   PLFLT *arg3 = (PLFLT *) 0 ;
05471   
05472   (void)jenv;
05473   (void)jcls;
05474   {
05475     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
05476     arg1   = ( *jenv )->GetArrayLength( jenv, jarg1 );
05477     Alen = arg1;
05478     setup_array_1d_d( &arg2, jxdata, Alen );
05479     // Could find no easy way to do this as part of freearg so I modified
05480     // the previous function so it ALWAYS mallocs and copies so that
05481     // the java array can be released immediately.
05482     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
05483   }
05484   {
05485     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
05486     if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
05487     {
05488       printf( "Vectors must be same length.\n" );
05489       return;
05490     }
05491     setup_array_1d_d( &arg3, jydata, Alen );
05492     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
05493   }
05494   plline(arg1,(double const *)arg2,(double const *)arg3);
05495   {
05496     free( arg2 );
05497   }
05498   {
05499     free( arg3 );
05500   }
05501 }
05502 
05503 
05504 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plline3(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jdoubleArray jarg4) {
05505   PLINT arg1 ;
05506   PLFLT *arg2 = (PLFLT *) 0 ;
05507   PLFLT *arg3 = (PLFLT *) 0 ;
05508   PLFLT *arg4 = (PLFLT *) 0 ;
05509   
05510   (void)jenv;
05511   (void)jcls;
05512   {
05513     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
05514     arg1   = ( *jenv )->GetArrayLength( jenv, jarg1 );
05515     Alen = arg1;
05516     setup_array_1d_d( &arg2, jxdata, Alen );
05517     // Could find no easy way to do this as part of freearg so I modified
05518     // the previous function so it ALWAYS mallocs and copies so that
05519     // the java array can be released immediately.
05520     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
05521   }
05522   {
05523     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
05524     if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
05525     {
05526       printf( "Vectors must be same length.\n" );
05527       return;
05528     }
05529     setup_array_1d_d( &arg3, jydata, Alen );
05530     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
05531   }
05532   {
05533     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg4, 0 );
05534     if ( ( *jenv )->GetArrayLength( jenv, jarg4 ) != Alen )
05535     {
05536       printf( "Vectors must be same length.\n" );
05537       return;
05538     }
05539     setup_array_1d_d( &arg4, jydata, Alen );
05540     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );
05541   }
05542   plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
05543   {
05544     free( arg2 );
05545   }
05546   {
05547     free( arg3 );
05548   }
05549   {
05550     free( arg4 );
05551   }
05552 }
05553 
05554 
05555 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pllsty(JNIEnv *jenv, jclass jcls, jint jarg1) {
05556   PLINT arg1 ;
05557   
05558   (void)jenv;
05559   (void)jcls;
05560   arg1 = (PLINT)jarg1; 
05561   pllsty(arg1);
05562 }
05563 
05564 
05565 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plmesh(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jobjectArray jarg3, jint jarg6) {
05566   PLFLT *arg1 = (PLFLT *) 0 ;
05567   PLFLT *arg2 = (PLFLT *) 0 ;
05568   PLFLT **arg3 = (PLFLT **) 0 ;
05569   PLINT arg4 ;
05570   PLINT arg5 ;
05571   PLINT arg6 ;
05572   
05573   (void)jenv;
05574   (void)jcls;
05575   {
05576     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
05577     Xlen = ( *jenv )->GetArrayLength( jenv, jarg1 );
05578     setup_array_1d_d( &arg1, jxdata, Xlen );
05579     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
05580   }
05581   {
05582     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg2, 0 );
05583     Ylen = ( *jenv )->GetArrayLength( jenv, jarg2 );
05584     setup_array_1d_d( &arg2, jydata, Ylen );
05585     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );
05586   }
05587   {
05588     jdouble  **adat;
05589     jobject *ai;
05590     int     nx = ( *jenv )->GetArrayLength( jenv, jarg3 );
05591     int     ny = -1;
05592     int     i, j;
05593     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
05594     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
05595     
05596     ( *jenv )->EnsureLocalCapacity( jenv, nx );
05597     
05598     for ( i = 0; i < nx; i++ )
05599     {
05600       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg3, i );
05601       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
05602       
05603       if ( ny == -1 )
05604       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
05605       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
05606       {
05607         printf( "Misshapen a array.\n" );
05608         for ( j = 0; j <= i; j++ )
05609         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
05610         free( adat );
05611         free( ai );
05612         return;
05613       }
05614     }
05615     
05616     if ( nx != Xlen || ny != Ylen )
05617     {
05618       printf( "Vectors must match matrix.\n" );
05619       for ( i = 0; i < nx; i++ )
05620       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
05621       free( adat );
05622       free( ai );
05623       return;
05624     }
05625     setup_array_2d_d( &arg3, adat, nx, ny );
05626     arg4 = nx;
05627     arg5 = ny;
05628     for ( i = 0; i < nx; i++ )
05629     {
05630       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
05631       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
05632     }
05633     
05634     
05635     free( adat );
05636     free( ai );
05637   }
05638   arg6 = (PLINT)jarg6; 
05639   plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
05640   {
05641     free( arg1 );
05642   }
05643   {
05644     free( arg2 );
05645   }
05646   {
05647     free( arg3[0] );
05648     free( arg3 );
05649   }
05650 }
05651 
05652 
05653 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plmeshc(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jobjectArray jarg3, jint jarg6, jdoubleArray jarg7) {
05654   PLFLT *arg1 = (PLFLT *) 0 ;
05655   PLFLT *arg2 = (PLFLT *) 0 ;
05656   PLFLT **arg3 = (PLFLT **) 0 ;
05657   PLINT arg4 ;
05658   PLINT arg5 ;
05659   PLINT arg6 ;
05660   PLFLT *arg7 = (PLFLT *) 0 ;
05661   PLINT arg8 ;
05662   
05663   (void)jenv;
05664   (void)jcls;
05665   {
05666     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
05667     Xlen = ( *jenv )->GetArrayLength( jenv, jarg1 );
05668     setup_array_1d_d( &arg1, jxdata, Xlen );
05669     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
05670   }
05671   {
05672     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg2, 0 );
05673     Ylen = ( *jenv )->GetArrayLength( jenv, jarg2 );
05674     setup_array_1d_d( &arg2, jydata, Ylen );
05675     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );
05676   }
05677   {
05678     jdouble  **adat;
05679     jobject *ai;
05680     int     nx = ( *jenv )->GetArrayLength( jenv, jarg3 );
05681     int     ny = -1;
05682     int     i, j;
05683     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
05684     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
05685     
05686     ( *jenv )->EnsureLocalCapacity( jenv, nx );
05687     
05688     for ( i = 0; i < nx; i++ )
05689     {
05690       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg3, i );
05691       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
05692       
05693       if ( ny == -1 )
05694       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
05695       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
05696       {
05697         printf( "Misshapen a array.\n" );
05698         for ( j = 0; j <= i; j++ )
05699         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
05700         free( adat );
05701         free( ai );
05702         return;
05703       }
05704     }
05705     
05706     if ( nx != Xlen || ny != Ylen )
05707     {
05708       printf( "Vectors must match matrix.\n" );
05709       for ( i = 0; i < nx; i++ )
05710       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
05711       free( adat );
05712       free( ai );
05713       return;
05714     }
05715     setup_array_2d_d( &arg3, adat, nx, ny );
05716     arg4 = nx;
05717     arg5 = ny;
05718     for ( i = 0; i < nx; i++ )
05719     {
05720       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
05721       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
05722     }
05723     
05724     
05725     free( adat );
05726     free( ai );
05727   }
05728   arg6 = (PLINT)jarg6; 
05729   {
05730     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg7, 0 );
05731     arg8 = ( *jenv )->GetArrayLength( jenv, jarg7 );
05732     setup_array_1d_d( &arg7, jxdata, arg8 );
05733     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg7, jxdata, 0 );
05734   }
05735   plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
05736   {
05737     free( arg1 );
05738   }
05739   {
05740     free( arg2 );
05741   }
05742   {
05743     free( arg3[0] );
05744     free( arg3 );
05745   }
05746   {
05747     free( arg7 );
05748   }
05749 }
05750 
05751 
05752 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plmkstrm(JNIEnv *jenv, jclass jcls, jintArray jarg1) {
05753   PLINT *arg1 = (PLINT *) 0 ;
05754   PLINT temp1 ;
05755   
05756   (void)jenv;
05757   (void)jcls;
05758   {
05759     if (!jarg1) {
05760       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
05761       return ;
05762     }
05763     if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
05764       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
05765       return ;
05766     }
05767     arg1 = &temp1; 
05768   }
05769   plmkstrm(arg1);
05770   {
05771     jint jvalue = (jint)temp1;
05772     (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
05773   }
05774   
05775 }
05776 
05777 
05778 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plmtex(JNIEnv *jenv, jclass jcls, jstring jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4, jstring jarg5) {
05779   char *arg1 = (char *) 0 ;
05780   PLFLT arg2 ;
05781   PLFLT arg3 ;
05782   PLFLT arg4 ;
05783   char *arg5 = (char *) 0 ;
05784   
05785   (void)jenv;
05786   (void)jcls;
05787   arg1 = 0;
05788   if (jarg1) {
05789     arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
05790     if (!arg1) return ;
05791   }
05792   arg2 = (PLFLT)jarg2; 
05793   arg3 = (PLFLT)jarg3; 
05794   arg4 = (PLFLT)jarg4; 
05795   arg5 = 0;
05796   if (jarg5) {
05797     arg5 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg5, 0);
05798     if (!arg5) return ;
05799   }
05800   plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
05801   if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
05802   if (arg5) (*jenv)->ReleaseStringUTFChars(jenv, jarg5, (const char *)arg5);
05803 }
05804 
05805 
05806 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plmtex3(JNIEnv *jenv, jclass jcls, jstring jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4, jstring jarg5) {
05807   char *arg1 = (char *) 0 ;
05808   PLFLT arg2 ;
05809   PLFLT arg3 ;
05810   PLFLT arg4 ;
05811   char *arg5 = (char *) 0 ;
05812   
05813   (void)jenv;
05814   (void)jcls;
05815   arg1 = 0;
05816   if (jarg1) {
05817     arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
05818     if (!arg1) return ;
05819   }
05820   arg2 = (PLFLT)jarg2; 
05821   arg3 = (PLFLT)jarg3; 
05822   arg4 = (PLFLT)jarg4; 
05823   arg5 = 0;
05824   if (jarg5) {
05825     arg5 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg5, 0);
05826     if (!arg5) return ;
05827   }
05828   plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
05829   if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
05830   if (arg5) (*jenv)->ReleaseStringUTFChars(jenv, jarg5, (const char *)arg5);
05831 }
05832 
05833 
05834 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plot3d(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jobjectArray jarg3, jint jarg6, jboolean jarg7) {
05835   PLFLT *arg1 = (PLFLT *) 0 ;
05836   PLFLT *arg2 = (PLFLT *) 0 ;
05837   PLFLT **arg3 = (PLFLT **) 0 ;
05838   PLINT arg4 ;
05839   PLINT arg5 ;
05840   PLINT arg6 ;
05841   PLBOOL arg7 ;
05842   
05843   (void)jenv;
05844   (void)jcls;
05845   {
05846     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
05847     Xlen = ( *jenv )->GetArrayLength( jenv, jarg1 );
05848     setup_array_1d_d( &arg1, jxdata, Xlen );
05849     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
05850   }
05851   {
05852     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg2, 0 );
05853     Ylen = ( *jenv )->GetArrayLength( jenv, jarg2 );
05854     setup_array_1d_d( &arg2, jydata, Ylen );
05855     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );
05856   }
05857   {
05858     jdouble  **adat;
05859     jobject *ai;
05860     int     nx = ( *jenv )->GetArrayLength( jenv, jarg3 );
05861     int     ny = -1;
05862     int     i, j;
05863     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
05864     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
05865     
05866     ( *jenv )->EnsureLocalCapacity( jenv, nx );
05867     
05868     for ( i = 0; i < nx; i++ )
05869     {
05870       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg3, i );
05871       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
05872       
05873       if ( ny == -1 )
05874       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
05875       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
05876       {
05877         printf( "Misshapen a array.\n" );
05878         for ( j = 0; j <= i; j++ )
05879         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
05880         free( adat );
05881         free( ai );
05882         return;
05883       }
05884     }
05885     
05886     if ( nx != Xlen || ny != Ylen )
05887     {
05888       printf( "Vectors must match matrix.\n" );
05889       for ( i = 0; i < nx; i++ )
05890       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
05891       free( adat );
05892       free( ai );
05893       return;
05894     }
05895     setup_array_2d_d( &arg3, adat, nx, ny );
05896     arg4 = nx;
05897     arg5 = ny;
05898     for ( i = 0; i < nx; i++ )
05899     {
05900       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
05901       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
05902     }
05903     
05904     
05905     free( adat );
05906     free( ai );
05907   }
05908   arg6 = (PLINT)jarg6; 
05909   
05910   arg7 = jarg7 ? 1 : 0;
05911   
05912   plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
05913   {
05914     free( arg1 );
05915   }
05916   {
05917     free( arg2 );
05918   }
05919   {
05920     free( arg3[0] );
05921     free( arg3 );
05922   }
05923 }
05924 
05925 
05926 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plot3dc(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jobjectArray jarg3, jint jarg6, jdoubleArray jarg7) {
05927   PLFLT *arg1 = (PLFLT *) 0 ;
05928   PLFLT *arg2 = (PLFLT *) 0 ;
05929   PLFLT **arg3 = (PLFLT **) 0 ;
05930   PLINT arg4 ;
05931   PLINT arg5 ;
05932   PLINT arg6 ;
05933   PLFLT *arg7 = (PLFLT *) 0 ;
05934   PLINT arg8 ;
05935   
05936   (void)jenv;
05937   (void)jcls;
05938   {
05939     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
05940     Xlen = ( *jenv )->GetArrayLength( jenv, jarg1 );
05941     setup_array_1d_d( &arg1, jxdata, Xlen );
05942     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
05943   }
05944   {
05945     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg2, 0 );
05946     Ylen = ( *jenv )->GetArrayLength( jenv, jarg2 );
05947     setup_array_1d_d( &arg2, jydata, Ylen );
05948     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );
05949   }
05950   {
05951     jdouble  **adat;
05952     jobject *ai;
05953     int     nx = ( *jenv )->GetArrayLength( jenv, jarg3 );
05954     int     ny = -1;
05955     int     i, j;
05956     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
05957     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
05958     
05959     ( *jenv )->EnsureLocalCapacity( jenv, nx );
05960     
05961     for ( i = 0; i < nx; i++ )
05962     {
05963       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg3, i );
05964       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
05965       
05966       if ( ny == -1 )
05967       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
05968       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
05969       {
05970         printf( "Misshapen a array.\n" );
05971         for ( j = 0; j <= i; j++ )
05972         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
05973         free( adat );
05974         free( ai );
05975         return;
05976       }
05977     }
05978     
05979     if ( nx != Xlen || ny != Ylen )
05980     {
05981       printf( "Vectors must match matrix.\n" );
05982       for ( i = 0; i < nx; i++ )
05983       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
05984       free( adat );
05985       free( ai );
05986       return;
05987     }
05988     setup_array_2d_d( &arg3, adat, nx, ny );
05989     arg4 = nx;
05990     arg5 = ny;
05991     for ( i = 0; i < nx; i++ )
05992     {
05993       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
05994       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
05995     }
05996     
05997     
05998     free( adat );
05999     free( ai );
06000   }
06001   arg6 = (PLINT)jarg6; 
06002   {
06003     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg7, 0 );
06004     arg8 = ( *jenv )->GetArrayLength( jenv, jarg7 );
06005     setup_array_1d_d( &arg7, jxdata, arg8 );
06006     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg7, jxdata, 0 );
06007   }
06008   plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
06009   {
06010     free( arg1 );
06011   }
06012   {
06013     free( arg2 );
06014   }
06015   {
06016     free( arg3[0] );
06017     free( arg3 );
06018   }
06019   {
06020     free( arg7 );
06021   }
06022 }
06023 
06024 
06025 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plot3dcl(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jobjectArray jarg3, jint jarg6, jdoubleArray jarg7, jint jarg9, jintArray jarg10, jintArray jarg12) {
06026   PLFLT *arg1 = (PLFLT *) 0 ;
06027   PLFLT *arg2 = (PLFLT *) 0 ;
06028   PLFLT **arg3 = (PLFLT **) 0 ;
06029   PLINT arg4 ;
06030   PLINT arg5 ;
06031   PLINT arg6 ;
06032   PLFLT *arg7 = (PLFLT *) 0 ;
06033   PLINT arg8 ;
06034   PLINT arg9 ;
06035   PLINT arg10 ;
06036   PLINT *arg11 = (PLINT *) 0 ;
06037   PLINT *arg12 = (PLINT *) 0 ;
06038   
06039   (void)jenv;
06040   (void)jcls;
06041   {
06042     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
06043     Xlen = ( *jenv )->GetArrayLength( jenv, jarg1 );
06044     setup_array_1d_d( &arg1, jxdata, Xlen );
06045     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
06046   }
06047   {
06048     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg2, 0 );
06049     Ylen = ( *jenv )->GetArrayLength( jenv, jarg2 );
06050     setup_array_1d_d( &arg2, jydata, Ylen );
06051     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );
06052   }
06053   {
06054     jdouble  **adat;
06055     jobject *ai;
06056     int     nx = ( *jenv )->GetArrayLength( jenv, jarg3 );
06057     int     ny = -1;
06058     int     i, j;
06059     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
06060     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
06061     
06062     ( *jenv )->EnsureLocalCapacity( jenv, nx );
06063     
06064     for ( i = 0; i < nx; i++ )
06065     {
06066       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg3, i );
06067       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
06068       
06069       if ( ny == -1 )
06070       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
06071       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
06072       {
06073         printf( "Misshapen a array.\n" );
06074         for ( j = 0; j <= i; j++ )
06075         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
06076         free( adat );
06077         free( ai );
06078         return;
06079       }
06080     }
06081     
06082     if ( nx != Xlen || ny != Ylen )
06083     {
06084       printf( "Vectors must match matrix.\n" );
06085       for ( i = 0; i < nx; i++ )
06086       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
06087       free( adat );
06088       free( ai );
06089       return;
06090     }
06091     setup_array_2d_d( &arg3, adat, nx, ny );
06092     arg4 = nx;
06093     arg5 = ny;
06094     for ( i = 0; i < nx; i++ )
06095     {
06096       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
06097       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
06098     }
06099     
06100     
06101     free( adat );
06102     free( ai );
06103   }
06104   arg6 = (PLINT)jarg6; 
06105   {
06106     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg7, 0 );
06107     arg8 = ( *jenv )->GetArrayLength( jenv, jarg7 );
06108     setup_array_1d_d( &arg7, jxdata, arg8 );
06109     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg7, jxdata, 0 );
06110   }
06111   arg9 = (PLINT)jarg9; 
06112   {
06113     jint *jxdata = ( *jenv )->GetIntArrayElements( jenv, jarg10, 0 );
06114     arg10   = ( *jenv )->GetArrayLength( jenv, jarg10 );
06115     Alen = arg10;
06116     setup_array_1d_i( &arg11, jxdata, Alen );
06117     // Could find no easy way to do this as part of freearg so I modified
06118     // the previous function so it ALWAYS mallocs and copies so that
06119     // the java array can be released immediately.
06120     ( *jenv )->ReleaseIntArrayElements( jenv, jarg10, jxdata, 0 );
06121   }
06122   {
06123     jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg12, 0 );
06124     if ( ( *jenv )->GetArrayLength( jenv, jarg12 ) != Alen )
06125     {
06126       printf( "Vectors must be same length.\n" );
06127       return;
06128     }
06129     setup_array_1d_i( &arg12, jydata, Alen );
06130     ( *jenv )->ReleaseIntArrayElements( jenv, jarg12, jydata, 0 );
06131   }
06132   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);
06133   {
06134     free( arg1 );
06135   }
06136   {
06137     free( arg2 );
06138   }
06139   {
06140     free( arg3[0] );
06141     free( arg3 );
06142   }
06143   {
06144     free( arg7 );
06145   }
06146   {
06147     free( arg11 );
06148   }
06149   {
06150     free( arg12 );
06151   }
06152 }
06153 
06154 
06155 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsurf3d(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jobjectArray jarg3, jint jarg6, jdoubleArray jarg7) {
06156   PLFLT *arg1 = (PLFLT *) 0 ;
06157   PLFLT *arg2 = (PLFLT *) 0 ;
06158   PLFLT **arg3 = (PLFLT **) 0 ;
06159   PLINT arg4 ;
06160   PLINT arg5 ;
06161   PLINT arg6 ;
06162   PLFLT *arg7 = (PLFLT *) 0 ;
06163   PLINT arg8 ;
06164   
06165   (void)jenv;
06166   (void)jcls;
06167   {
06168     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
06169     Xlen = ( *jenv )->GetArrayLength( jenv, jarg1 );
06170     setup_array_1d_d( &arg1, jxdata, Xlen );
06171     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
06172   }
06173   {
06174     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg2, 0 );
06175     Ylen = ( *jenv )->GetArrayLength( jenv, jarg2 );
06176     setup_array_1d_d( &arg2, jydata, Ylen );
06177     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );
06178   }
06179   {
06180     jdouble  **adat;
06181     jobject *ai;
06182     int     nx = ( *jenv )->GetArrayLength( jenv, jarg3 );
06183     int     ny = -1;
06184     int     i, j;
06185     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
06186     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
06187     
06188     ( *jenv )->EnsureLocalCapacity( jenv, nx );
06189     
06190     for ( i = 0; i < nx; i++ )
06191     {
06192       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg3, i );
06193       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
06194       
06195       if ( ny == -1 )
06196       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
06197       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
06198       {
06199         printf( "Misshapen a array.\n" );
06200         for ( j = 0; j <= i; j++ )
06201         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
06202         free( adat );
06203         free( ai );
06204         return;
06205       }
06206     }
06207     
06208     if ( nx != Xlen || ny != Ylen )
06209     {
06210       printf( "Vectors must match matrix.\n" );
06211       for ( i = 0; i < nx; i++ )
06212       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
06213       free( adat );
06214       free( ai );
06215       return;
06216     }
06217     setup_array_2d_d( &arg3, adat, nx, ny );
06218     arg4 = nx;
06219     arg5 = ny;
06220     for ( i = 0; i < nx; i++ )
06221     {
06222       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
06223       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
06224     }
06225     
06226     
06227     free( adat );
06228     free( ai );
06229   }
06230   arg6 = (PLINT)jarg6; 
06231   {
06232     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg7, 0 );
06233     arg8 = ( *jenv )->GetArrayLength( jenv, jarg7 );
06234     setup_array_1d_d( &arg7, jxdata, arg8 );
06235     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg7, jxdata, 0 );
06236   }
06237   plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
06238   {
06239     free( arg1 );
06240   }
06241   {
06242     free( arg2 );
06243   }
06244   {
06245     free( arg3[0] );
06246     free( arg3 );
06247   }
06248   {
06249     free( arg7 );
06250   }
06251 }
06252 
06253 
06254 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsurf3dl(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jobjectArray jarg3, jint jarg6, jdoubleArray jarg7, jint jarg9, jintArray jarg10, jintArray jarg12) {
06255   PLFLT *arg1 = (PLFLT *) 0 ;
06256   PLFLT *arg2 = (PLFLT *) 0 ;
06257   PLFLT **arg3 = (PLFLT **) 0 ;
06258   PLINT arg4 ;
06259   PLINT arg5 ;
06260   PLINT arg6 ;
06261   PLFLT *arg7 = (PLFLT *) 0 ;
06262   PLINT arg8 ;
06263   PLINT arg9 ;
06264   PLINT arg10 ;
06265   PLINT *arg11 = (PLINT *) 0 ;
06266   PLINT *arg12 = (PLINT *) 0 ;
06267   
06268   (void)jenv;
06269   (void)jcls;
06270   {
06271     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
06272     Xlen = ( *jenv )->GetArrayLength( jenv, jarg1 );
06273     setup_array_1d_d( &arg1, jxdata, Xlen );
06274     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
06275   }
06276   {
06277     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg2, 0 );
06278     Ylen = ( *jenv )->GetArrayLength( jenv, jarg2 );
06279     setup_array_1d_d( &arg2, jydata, Ylen );
06280     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );
06281   }
06282   {
06283     jdouble  **adat;
06284     jobject *ai;
06285     int     nx = ( *jenv )->GetArrayLength( jenv, jarg3 );
06286     int     ny = -1;
06287     int     i, j;
06288     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
06289     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
06290     
06291     ( *jenv )->EnsureLocalCapacity( jenv, nx );
06292     
06293     for ( i = 0; i < nx; i++ )
06294     {
06295       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg3, i );
06296       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
06297       
06298       if ( ny == -1 )
06299       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
06300       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
06301       {
06302         printf( "Misshapen a array.\n" );
06303         for ( j = 0; j <= i; j++ )
06304         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
06305         free( adat );
06306         free( ai );
06307         return;
06308       }
06309     }
06310     
06311     if ( nx != Xlen || ny != Ylen )
06312     {
06313       printf( "Vectors must match matrix.\n" );
06314       for ( i = 0; i < nx; i++ )
06315       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
06316       free( adat );
06317       free( ai );
06318       return;
06319     }
06320     setup_array_2d_d( &arg3, adat, nx, ny );
06321     arg4 = nx;
06322     arg5 = ny;
06323     for ( i = 0; i < nx; i++ )
06324     {
06325       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
06326       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
06327     }
06328     
06329     
06330     free( adat );
06331     free( ai );
06332   }
06333   arg6 = (PLINT)jarg6; 
06334   {
06335     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg7, 0 );
06336     arg8 = ( *jenv )->GetArrayLength( jenv, jarg7 );
06337     setup_array_1d_d( &arg7, jxdata, arg8 );
06338     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg7, jxdata, 0 );
06339   }
06340   arg9 = (PLINT)jarg9; 
06341   {
06342     jint *jxdata = ( *jenv )->GetIntArrayElements( jenv, jarg10, 0 );
06343     arg10   = ( *jenv )->GetArrayLength( jenv, jarg10 );
06344     Alen = arg10;
06345     setup_array_1d_i( &arg11, jxdata, Alen );
06346     // Could find no easy way to do this as part of freearg so I modified
06347     // the previous function so it ALWAYS mallocs and copies so that
06348     // the java array can be released immediately.
06349     ( *jenv )->ReleaseIntArrayElements( jenv, jarg10, jxdata, 0 );
06350   }
06351   {
06352     jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg12, 0 );
06353     if ( ( *jenv )->GetArrayLength( jenv, jarg12 ) != Alen )
06354     {
06355       printf( "Vectors must be same length.\n" );
06356       return;
06357     }
06358     setup_array_1d_i( &arg12, jydata, Alen );
06359     ( *jenv )->ReleaseIntArrayElements( jenv, jarg12, jydata, 0 );
06360   }
06361   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);
06362   {
06363     free( arg1 );
06364   }
06365   {
06366     free( arg2 );
06367   }
06368   {
06369     free( arg3[0] );
06370     free( arg3 );
06371   }
06372   {
06373     free( arg7 );
06374   }
06375   {
06376     free( arg11 );
06377   }
06378   {
06379     free( arg12 );
06380   }
06381 }
06382 
06383 
06384 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_plparseopts(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jint jarg3) {
06385   jint jresult = 0 ;
06386   int *arg1 = (int *) 0 ;
06387   char **arg2 = (char **) 0 ;
06388   PLINT arg3 ;
06389   int size1 ;
06390   PLINT result;
06391   
06392   (void)jenv;
06393   (void)jcls;
06394   {
06395     int i = 0;
06396     size1 = (int) ( ( *jenv )->GetArrayLength( jenv, jarg1 ) );
06397     arg1   = &size1;
06398     arg2   = (char **) malloc( ( size1 + 1 ) * sizeof ( char * ) );
06399     // make a copy of each string
06400     for ( i = 0; i < size1; i++ )
06401     {
06402       jstring    j_string   = (jstring) ( *jenv )->GetObjectArrayElement( jenv, jarg1, i );
06403       const char * c_string = (char *) ( *jenv )->GetStringUTFChars( jenv, j_string, 0 );
06404       // Commented out version straight from swig documentation, but I think
06405       // it is wrong.
06406       //    arg2[i] = malloc(strlen((c_string)+1)*sizeof(const char *));
06407       arg2[i] = malloc( ( strlen( c_string ) + 1 ) * sizeof ( const char * ) );
06408       strcpy( arg2[i], c_string );
06409       ( *jenv )->ReleaseStringUTFChars( jenv, j_string, c_string );
06410       ( *jenv )->DeleteLocalRef( jenv, j_string );
06411     }
06412     arg2[i] = 0;
06413   }
06414   arg3 = (PLINT)jarg3; 
06415   result = (PLINT)plparseopts(arg1,(char const **)arg2,arg3);
06416   jresult = (jint)result; 
06417   {
06418     int i;
06419     // Commented out version straight from swig documentation, but I think
06420     // it is wrong.
06421     // for (i=0; i<size1-1; i++)
06422     for ( i = 0; i < size1; i++ )
06423     free( arg2[i] );
06424     free( arg2 );
06425   }
06426   return jresult;
06427 }
06428 
06429 
06430 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plpat(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg3) {
06431   PLINT arg1 ;
06432   PLINT *arg2 = (PLINT *) 0 ;
06433   PLINT *arg3 = (PLINT *) 0 ;
06434   
06435   (void)jenv;
06436   (void)jcls;
06437   {
06438     jint *jxdata = ( *jenv )->GetIntArrayElements( jenv, jarg1, 0 );
06439     arg1   = ( *jenv )->GetArrayLength( jenv, jarg1 );
06440     Alen = arg1;
06441     setup_array_1d_i( &arg2, jxdata, Alen );
06442     // Could find no easy way to do this as part of freearg so I modified
06443     // the previous function so it ALWAYS mallocs and copies so that
06444     // the java array can be released immediately.
06445     ( *jenv )->ReleaseIntArrayElements( jenv, jarg1, jxdata, 0 );
06446   }
06447   {
06448     jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg3, 0 );
06449     if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
06450     {
06451       printf( "Vectors must be same length.\n" );
06452       return;
06453     }
06454     setup_array_1d_i( &arg3, jydata, Alen );
06455     ( *jenv )->ReleaseIntArrayElements( jenv, jarg3, jydata, 0 );
06456   }
06457   plpat(arg1,(int const *)arg2,(int const *)arg3);
06458   {
06459     free( arg2 );
06460   }
06461   {
06462     free( arg3 );
06463   }
06464 }
06465 
06466 
06467 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plpoin(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jint jarg4) {
06468   PLINT arg1 ;
06469   PLFLT *arg2 = (PLFLT *) 0 ;
06470   PLFLT *arg3 = (PLFLT *) 0 ;
06471   PLINT arg4 ;
06472   
06473   (void)jenv;
06474   (void)jcls;
06475   {
06476     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
06477     arg1   = ( *jenv )->GetArrayLength( jenv, jarg1 );
06478     Alen = arg1;
06479     setup_array_1d_d( &arg2, jxdata, Alen );
06480     // Could find no easy way to do this as part of freearg so I modified
06481     // the previous function so it ALWAYS mallocs and copies so that
06482     // the java array can be released immediately.
06483     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
06484   }
06485   {
06486     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
06487     if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
06488     {
06489       printf( "Vectors must be same length.\n" );
06490       return;
06491     }
06492     setup_array_1d_d( &arg3, jydata, Alen );
06493     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
06494   }
06495   arg4 = (PLINT)jarg4; 
06496   plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
06497   {
06498     free( arg2 );
06499   }
06500   {
06501     free( arg3 );
06502   }
06503 }
06504 
06505 
06506 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plpoin3(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jdoubleArray jarg4, jint jarg5) {
06507   PLINT arg1 ;
06508   PLFLT *arg2 = (PLFLT *) 0 ;
06509   PLFLT *arg3 = (PLFLT *) 0 ;
06510   PLFLT *arg4 = (PLFLT *) 0 ;
06511   PLINT arg5 ;
06512   
06513   (void)jenv;
06514   (void)jcls;
06515   {
06516     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
06517     arg1   = ( *jenv )->GetArrayLength( jenv, jarg1 );
06518     Alen = arg1;
06519     setup_array_1d_d( &arg2, jxdata, Alen );
06520     // Could find no easy way to do this as part of freearg so I modified
06521     // the previous function so it ALWAYS mallocs and copies so that
06522     // the java array can be released immediately.
06523     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
06524   }
06525   {
06526     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
06527     if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
06528     {
06529       printf( "Vectors must be same length.\n" );
06530       return;
06531     }
06532     setup_array_1d_d( &arg3, jydata, Alen );
06533     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
06534   }
06535   {
06536     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg4, 0 );
06537     if ( ( *jenv )->GetArrayLength( jenv, jarg4 ) != Alen )
06538     {
06539       printf( "Vectors must be same length.\n" );
06540       return;
06541     }
06542     setup_array_1d_d( &arg4, jydata, Alen );
06543     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );
06544   }
06545   arg5 = (PLINT)jarg5; 
06546   plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
06547   {
06548     free( arg2 );
06549   }
06550   {
06551     free( arg3 );
06552   }
06553   {
06554     free( arg4 );
06555   }
06556 }
06557 
06558 
06559 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plpoly3(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jdoubleArray jarg4, jbooleanArray jarg5, jboolean jarg6) {
06560   PLINT arg1 ;
06561   PLFLT *arg2 = (PLFLT *) 0 ;
06562   PLFLT *arg3 = (PLFLT *) 0 ;
06563   PLFLT *arg4 = (PLFLT *) 0 ;
06564   PLBOOL *arg5 = (PLBOOL *) 0 ;
06565   PLBOOL arg6 ;
06566   
06567   (void)jenv;
06568   (void)jcls;
06569   {
06570     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
06571     arg1   = ( *jenv )->GetArrayLength( jenv, jarg1 );
06572     Alen = arg1;
06573     setup_array_1d_d( &arg2, jxdata, Alen );
06574     // Could find no easy way to do this as part of freearg so I modified
06575     // the previous function so it ALWAYS mallocs and copies so that
06576     // the java array can be released immediately.
06577     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
06578   }
06579   {
06580     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
06581     if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
06582     {
06583       printf( "Vectors must be same length.\n" );
06584       return;
06585     }
06586     setup_array_1d_d( &arg3, jydata, Alen );
06587     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
06588   }
06589   {
06590     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg4, 0 );
06591     if ( ( *jenv )->GetArrayLength( jenv, jarg4 ) != Alen )
06592     {
06593       printf( "Vectors must be same length.\n" );
06594       return;
06595     }
06596     setup_array_1d_d( &arg4, jydata, Alen );
06597     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );
06598   }
06599   {
06600     jboolean *jydata = ( *jenv )->GetBooleanArrayElements( jenv, jarg5, 0 );
06601     if ( ( *jenv )->GetArrayLength( jenv, jarg5 ) < Alen - 1 )
06602     {
06603       printf( "Vector must be at least length of others minus 1.\n" );
06604       return;
06605     }
06606     setup_array_1d_b( &arg5, jydata, Alen );
06607     ( *jenv )->ReleaseBooleanArrayElements( jenv, jarg5, jydata, 0 );
06608   }
06609   
06610   arg6 = jarg6 ? 1 : 0;
06611   
06612   plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
06613   {
06614     free( arg2 );
06615   }
06616   {
06617     free( arg3 );
06618   }
06619   {
06620     free( arg4 );
06621   }
06622   {
06623     free( arg5 );
06624   }
06625 }
06626 
06627 
06628 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plprec(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {
06629   PLINT arg1 ;
06630   PLINT arg2 ;
06631   
06632   (void)jenv;
06633   (void)jcls;
06634   arg1 = (PLINT)jarg1; 
06635   arg2 = (PLINT)jarg2; 
06636   plprec(arg1,arg2);
06637 }
06638 
06639 
06640 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plpsty(JNIEnv *jenv, jclass jcls, jint jarg1) {
06641   PLINT arg1 ;
06642   
06643   (void)jenv;
06644   (void)jcls;
06645   arg1 = (PLINT)jarg1; 
06646   plpsty(arg1);
06647 }
06648 
06649 
06650 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plptex(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4, jdouble jarg5, jstring jarg6) {
06651   PLFLT arg1 ;
06652   PLFLT arg2 ;
06653   PLFLT arg3 ;
06654   PLFLT arg4 ;
06655   PLFLT arg5 ;
06656   char *arg6 = (char *) 0 ;
06657   
06658   (void)jenv;
06659   (void)jcls;
06660   arg1 = (PLFLT)jarg1; 
06661   arg2 = (PLFLT)jarg2; 
06662   arg3 = (PLFLT)jarg3; 
06663   arg4 = (PLFLT)jarg4; 
06664   arg5 = (PLFLT)jarg5; 
06665   arg6 = 0;
06666   if (jarg6) {
06667     arg6 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg6, 0);
06668     if (!arg6) return ;
06669   }
06670   plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
06671   if (arg6) (*jenv)->ReleaseStringUTFChars(jenv, jarg6, (const char *)arg6);
06672 }
06673 
06674 
06675 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plptex3(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4, jdouble jarg5, jdouble jarg6, jdouble jarg7, jdouble jarg8, jdouble jarg9, jdouble jarg10, jstring jarg11) {
06676   PLFLT arg1 ;
06677   PLFLT arg2 ;
06678   PLFLT arg3 ;
06679   PLFLT arg4 ;
06680   PLFLT arg5 ;
06681   PLFLT arg6 ;
06682   PLFLT arg7 ;
06683   PLFLT arg8 ;
06684   PLFLT arg9 ;
06685   PLFLT arg10 ;
06686   char *arg11 = (char *) 0 ;
06687   
06688   (void)jenv;
06689   (void)jcls;
06690   arg1 = (PLFLT)jarg1; 
06691   arg2 = (PLFLT)jarg2; 
06692   arg3 = (PLFLT)jarg3; 
06693   arg4 = (PLFLT)jarg4; 
06694   arg5 = (PLFLT)jarg5; 
06695   arg6 = (PLFLT)jarg6; 
06696   arg7 = (PLFLT)jarg7; 
06697   arg8 = (PLFLT)jarg8; 
06698   arg9 = (PLFLT)jarg9; 
06699   arg10 = (PLFLT)jarg10; 
06700   arg11 = 0;
06701   if (jarg11) {
06702     arg11 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg11, 0);
06703     if (!arg11) return ;
06704   }
06705   plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
06706   if (arg11) (*jenv)->ReleaseStringUTFChars(jenv, jarg11, (const char *)arg11);
06707 }
06708 
06709 
06710 SWIGEXPORT jdouble JNICALL Java_plplot_core_plplotjavacJNI_plrandd(JNIEnv *jenv, jclass jcls) {
06711   jdouble jresult = 0 ;
06712   PLFLT result;
06713   
06714   (void)jenv;
06715   (void)jcls;
06716   result = (PLFLT)plrandd();
06717   jresult = (jdouble)result; 
06718   return jresult;
06719 }
06720 
06721 
06722 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plreplot(JNIEnv *jenv, jclass jcls) {
06723   (void)jenv;
06724   (void)jcls;
06725   plreplot();
06726 }
06727 
06728 
06729 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plrgbhls(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdoubleArray jarg4, jdoubleArray jarg5, jdoubleArray jarg6) {
06730   PLFLT arg1 ;
06731   PLFLT arg2 ;
06732   PLFLT arg3 ;
06733   PLFLT *arg4 = (PLFLT *) 0 ;
06734   PLFLT *arg5 = (PLFLT *) 0 ;
06735   PLFLT *arg6 = (PLFLT *) 0 ;
06736   PLFLT temp4 ;
06737   PLFLT temp5 ;
06738   PLFLT temp6 ;
06739   
06740   (void)jenv;
06741   (void)jcls;
06742   arg1 = (PLFLT)jarg1; 
06743   arg2 = (PLFLT)jarg2; 
06744   arg3 = (PLFLT)jarg3; 
06745   {
06746     if (!jarg4) {
06747       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
06748       return ;
06749     }
06750     if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
06751       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
06752       return ;
06753     }
06754     arg4 = &temp4; 
06755   }
06756   {
06757     if (!jarg5) {
06758       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
06759       return ;
06760     }
06761     if ((*jenv)->GetArrayLength(jenv, jarg5) == 0) {
06762       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
06763       return ;
06764     }
06765     arg5 = &temp5; 
06766   }
06767   {
06768     if (!jarg6) {
06769       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
06770       return ;
06771     }
06772     if ((*jenv)->GetArrayLength(jenv, jarg6) == 0) {
06773       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
06774       return ;
06775     }
06776     arg6 = &temp6; 
06777   }
06778   plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
06779   {
06780     jdouble jvalue = (jdouble)temp4;
06781     (*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);
06782   }
06783   {
06784     jdouble jvalue = (jdouble)temp5;
06785     (*jenv)->SetDoubleArrayRegion(jenv, jarg5, 0, 1, &jvalue);
06786   }
06787   {
06788     jdouble jvalue = (jdouble)temp6;
06789     (*jenv)->SetDoubleArrayRegion(jenv, jarg6, 0, 1, &jvalue);
06790   }
06791   
06792   
06793   
06794 }
06795 
06796 
06797 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plschr(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2) {
06798   PLFLT arg1 ;
06799   PLFLT arg2 ;
06800   
06801   (void)jenv;
06802   (void)jcls;
06803   arg1 = (PLFLT)jarg1; 
06804   arg2 = (PLFLT)jarg2; 
06805   plschr(arg1,arg2);
06806 }
06807 
06808 
06809 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscmap0(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2, jintArray jarg3) {
06810   PLINT *arg1 = (PLINT *) 0 ;
06811   PLINT *arg2 = (PLINT *) 0 ;
06812   PLINT *arg3 = (PLINT *) 0 ;
06813   PLINT arg4 ;
06814   
06815   (void)jenv;
06816   (void)jcls;
06817   {
06818     jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg1, 0 );
06819     Alen = ( *jenv )->GetArrayLength( jenv, jarg1 );
06820     setup_array_1d_i( &arg1, jydata, Alen );
06821     ( *jenv )->ReleaseIntArrayElements( jenv, jarg1, jydata, 0 );
06822   }
06823   {
06824     jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg2, 0 );
06825     if ( ( *jenv )->GetArrayLength( jenv, jarg2 ) != Alen )
06826     {
06827       printf( "Vectors must be same length.\n" );
06828       return;
06829     }
06830     setup_array_1d_i( &arg2, jydata, Alen );
06831     ( *jenv )->ReleaseIntArrayElements( jenv, jarg2, jydata, 0 );
06832   }
06833   {
06834     jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg3, 0 );
06835     if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
06836     {
06837       printf( "Vectors must be same length.\n" );
06838       return;
06839     }
06840     arg4 = ( *jenv )->GetArrayLength( jenv, jarg3 );
06841     setup_array_1d_i( &arg3, jydata, Alen );
06842     ( *jenv )->ReleaseIntArrayElements( jenv, jarg3, jydata, 0 );
06843   }
06844   plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
06845   {
06846     free( arg1 );
06847   }
06848   {
06849     free( arg2 );
06850   }
06851   {
06852     free( arg3 );
06853   }
06854 }
06855 
06856 
06857 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscmap0a(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2, jintArray jarg3, jdoubleArray jarg4) {
06858   PLINT *arg1 = (PLINT *) 0 ;
06859   PLINT *arg2 = (PLINT *) 0 ;
06860   PLINT *arg3 = (PLINT *) 0 ;
06861   PLFLT *arg4 = (PLFLT *) 0 ;
06862   PLINT arg5 ;
06863   
06864   (void)jenv;
06865   (void)jcls;
06866   {
06867     jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg1, 0 );
06868     Alen = ( *jenv )->GetArrayLength( jenv, jarg1 );
06869     setup_array_1d_i( &arg1, jydata, Alen );
06870     ( *jenv )->ReleaseIntArrayElements( jenv, jarg1, jydata, 0 );
06871   }
06872   {
06873     jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg2, 0 );
06874     if ( ( *jenv )->GetArrayLength( jenv, jarg2 ) != Alen )
06875     {
06876       printf( "Vectors must be same length.\n" );
06877       return;
06878     }
06879     setup_array_1d_i( &arg2, jydata, Alen );
06880     ( *jenv )->ReleaseIntArrayElements( jenv, jarg2, jydata, 0 );
06881   }
06882   {
06883     jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg3, 0 );
06884     if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
06885     {
06886       printf( "Vectors must be same length.\n" );
06887       return;
06888     }
06889     setup_array_1d_i( &arg3, jydata, Alen );
06890     ( *jenv )->ReleaseIntArrayElements( jenv, jarg3, jydata, 0 );
06891   }
06892   {
06893     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg4, 0 );
06894     arg5 = ( *jenv )->GetArrayLength( jenv, jarg4 );
06895     if ( ( *jenv )->GetArrayLength( jenv, jarg4 ) != Alen )
06896     {
06897       printf( "Vectors must be same length.\n" );
06898       return;
06899     }
06900     setup_array_1d_d( &arg4, jydata, Alen );
06901     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );
06902   }
06903   plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
06904   {
06905     free( arg1 );
06906   }
06907   {
06908     free( arg2 );
06909   }
06910   {
06911     free( arg3 );
06912   }
06913   {
06914     free( arg4 );
06915   }
06916 }
06917 
06918 
06919 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscmap0n(JNIEnv *jenv, jclass jcls, jint jarg1) {
06920   PLINT arg1 ;
06921   
06922   (void)jenv;
06923   (void)jcls;
06924   arg1 = (PLINT)jarg1; 
06925   plscmap0n(arg1);
06926 }
06927 
06928 
06929 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscmap1(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2, jintArray jarg3) {
06930   PLINT *arg1 = (PLINT *) 0 ;
06931   PLINT *arg2 = (PLINT *) 0 ;
06932   PLINT *arg3 = (PLINT *) 0 ;
06933   PLINT arg4 ;
06934   
06935   (void)jenv;
06936   (void)jcls;
06937   {
06938     jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg1, 0 );
06939     Alen = ( *jenv )->GetArrayLength( jenv, jarg1 );
06940     setup_array_1d_i( &arg1, jydata, Alen );
06941     ( *jenv )->ReleaseIntArrayElements( jenv, jarg1, jydata, 0 );
06942   }
06943   {
06944     jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg2, 0 );
06945     if ( ( *jenv )->GetArrayLength( jenv, jarg2 ) != Alen )
06946     {
06947       printf( "Vectors must be same length.\n" );
06948       return;
06949     }
06950     setup_array_1d_i( &arg2, jydata, Alen );
06951     ( *jenv )->ReleaseIntArrayElements( jenv, jarg2, jydata, 0 );
06952   }
06953   {
06954     jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg3, 0 );
06955     if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
06956     {
06957       printf( "Vectors must be same length.\n" );
06958       return;
06959     }
06960     arg4 = ( *jenv )->GetArrayLength( jenv, jarg3 );
06961     setup_array_1d_i( &arg3, jydata, Alen );
06962     ( *jenv )->ReleaseIntArrayElements( jenv, jarg3, jydata, 0 );
06963   }
06964   plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
06965   {
06966     free( arg1 );
06967   }
06968   {
06969     free( arg2 );
06970   }
06971   {
06972     free( arg3 );
06973   }
06974 }
06975 
06976 
06977 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscmap1a(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2, jintArray jarg3, jdoubleArray jarg4) {
06978   PLINT *arg1 = (PLINT *) 0 ;
06979   PLINT *arg2 = (PLINT *) 0 ;
06980   PLINT *arg3 = (PLINT *) 0 ;
06981   PLFLT *arg4 = (PLFLT *) 0 ;
06982   PLINT arg5 ;
06983   
06984   (void)jenv;
06985   (void)jcls;
06986   {
06987     jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg1, 0 );
06988     Alen = ( *jenv )->GetArrayLength( jenv, jarg1 );
06989     setup_array_1d_i( &arg1, jydata, Alen );
06990     ( *jenv )->ReleaseIntArrayElements( jenv, jarg1, jydata, 0 );
06991   }
06992   {
06993     jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg2, 0 );
06994     if ( ( *jenv )->GetArrayLength( jenv, jarg2 ) != Alen )
06995     {
06996       printf( "Vectors must be same length.\n" );
06997       return;
06998     }
06999     setup_array_1d_i( &arg2, jydata, Alen );
07000     ( *jenv )->ReleaseIntArrayElements( jenv, jarg2, jydata, 0 );
07001   }
07002   {
07003     jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg3, 0 );
07004     if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
07005     {
07006       printf( "Vectors must be same length.\n" );
07007       return;
07008     }
07009     setup_array_1d_i( &arg3, jydata, Alen );
07010     ( *jenv )->ReleaseIntArrayElements( jenv, jarg3, jydata, 0 );
07011   }
07012   {
07013     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg4, 0 );
07014     arg5 = ( *jenv )->GetArrayLength( jenv, jarg4 );
07015     if ( ( *jenv )->GetArrayLength( jenv, jarg4 ) != Alen )
07016     {
07017       printf( "Vectors must be same length.\n" );
07018       return;
07019     }
07020     setup_array_1d_d( &arg4, jydata, Alen );
07021     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );
07022   }
07023   plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
07024   {
07025     free( arg1 );
07026   }
07027   {
07028     free( arg2 );
07029   }
07030   {
07031     free( arg3 );
07032   }
07033   {
07034     free( arg4 );
07035   }
07036 }
07037 
07038 
07039 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscmap1l(JNIEnv *jenv, jclass jcls, jboolean jarg1, jdoubleArray jarg2, jdoubleArray jarg4, jdoubleArray jarg5, jdoubleArray jarg6, jbooleanArray jarg7) {
07040   PLBOOL arg1 ;
07041   PLINT arg2 ;
07042   PLFLT *arg3 = (PLFLT *) 0 ;
07043   PLFLT *arg4 = (PLFLT *) 0 ;
07044   PLFLT *arg5 = (PLFLT *) 0 ;
07045   PLFLT *arg6 = (PLFLT *) 0 ;
07046   PLBOOL *arg7 = (PLBOOL *) 0 ;
07047   
07048   (void)jenv;
07049   (void)jcls;
07050   
07051   arg1 = jarg1 ? 1 : 0;
07052   
07053   {
07054     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg2, 0 );
07055     arg2   = ( *jenv )->GetArrayLength( jenv, jarg2 );
07056     Alen = arg2;
07057     setup_array_1d_d( &arg3, jxdata, Alen );
07058     // Could find no easy way to do this as part of freearg so I modified
07059     // the previous function so it ALWAYS mallocs and copies so that
07060     // the java array can be released immediately.
07061     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg2, jxdata, 0 );
07062   }
07063   {
07064     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg4, 0 );
07065     if ( ( *jenv )->GetArrayLength( jenv, jarg4 ) != Alen )
07066     {
07067       printf( "Vectors must be same length.\n" );
07068       return;
07069     }
07070     setup_array_1d_d( &arg4, jydata, Alen );
07071     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );
07072   }
07073   {
07074     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg5, 0 );
07075     if ( ( *jenv )->GetArrayLength( jenv, jarg5 ) != Alen )
07076     {
07077       printf( "Vectors must be same length.\n" );
07078       return;
07079     }
07080     setup_array_1d_d( &arg5, jydata, Alen );
07081     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg5, jydata, 0 );
07082   }
07083   {
07084     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg6, 0 );
07085     if ( ( *jenv )->GetArrayLength( jenv, jarg6 ) != Alen )
07086     {
07087       printf( "Vectors must be same length.\n" );
07088       return;
07089     }
07090     setup_array_1d_d( &arg6, jydata, Alen );
07091     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg6, jydata, 0 );
07092   }
07093   {
07094     if ( jarg7 != NULL )
07095     {
07096       jboolean *jydata = ( *jenv )->GetBooleanArrayElements( jenv, jarg7, 0 );
07097       if ( ( *jenv )->GetArrayLength( jenv, jarg7 ) < Alen - 1 )
07098       {
07099         printf( "Vector must be at least length of others minus 1.\n" );
07100         return;
07101       }
07102       setup_array_1d_b( &arg7, jydata, Alen );
07103       ( *jenv )->ReleaseBooleanArrayElements( jenv, jarg7, jydata, 0 );
07104     }
07105     else
07106     {
07107       arg7 = NULL;
07108     }
07109   }
07110   plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
07111   {
07112     free( arg3 );
07113   }
07114   {
07115     free( arg4 );
07116   }
07117   {
07118     free( arg5 );
07119   }
07120   {
07121     free( arg6 );
07122   }
07123   {
07124     if ( arg7 != NULL )
07125     free( arg7 );
07126   }
07127 }
07128 
07129 
07130 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscmap1la(JNIEnv *jenv, jclass jcls, jboolean jarg1, jdoubleArray jarg2, jdoubleArray jarg4, jdoubleArray jarg5, jdoubleArray jarg6, jdoubleArray jarg7, jbooleanArray jarg8) {
07131   PLBOOL arg1 ;
07132   PLINT arg2 ;
07133   PLFLT *arg3 = (PLFLT *) 0 ;
07134   PLFLT *arg4 = (PLFLT *) 0 ;
07135   PLFLT *arg5 = (PLFLT *) 0 ;
07136   PLFLT *arg6 = (PLFLT *) 0 ;
07137   PLFLT *arg7 = (PLFLT *) 0 ;
07138   PLBOOL *arg8 = (PLBOOL *) 0 ;
07139   
07140   (void)jenv;
07141   (void)jcls;
07142   
07143   arg1 = jarg1 ? 1 : 0;
07144   
07145   {
07146     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg2, 0 );
07147     arg2   = ( *jenv )->GetArrayLength( jenv, jarg2 );
07148     Alen = arg2;
07149     setup_array_1d_d( &arg3, jxdata, Alen );
07150     // Could find no easy way to do this as part of freearg so I modified
07151     // the previous function so it ALWAYS mallocs and copies so that
07152     // the java array can be released immediately.
07153     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg2, jxdata, 0 );
07154   }
07155   {
07156     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg4, 0 );
07157     if ( ( *jenv )->GetArrayLength( jenv, jarg4 ) != Alen )
07158     {
07159       printf( "Vectors must be same length.\n" );
07160       return;
07161     }
07162     setup_array_1d_d( &arg4, jydata, Alen );
07163     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );
07164   }
07165   {
07166     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg5, 0 );
07167     if ( ( *jenv )->GetArrayLength( jenv, jarg5 ) != Alen )
07168     {
07169       printf( "Vectors must be same length.\n" );
07170       return;
07171     }
07172     setup_array_1d_d( &arg5, jydata, Alen );
07173     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg5, jydata, 0 );
07174   }
07175   {
07176     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg6, 0 );
07177     if ( ( *jenv )->GetArrayLength( jenv, jarg6 ) != Alen )
07178     {
07179       printf( "Vectors must be same length.\n" );
07180       return;
07181     }
07182     setup_array_1d_d( &arg6, jydata, Alen );
07183     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg6, jydata, 0 );
07184   }
07185   {
07186     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg7, 0 );
07187     if ( ( *jenv )->GetArrayLength( jenv, jarg7 ) != Alen )
07188     {
07189       printf( "Vectors must be same length.\n" );
07190       return;
07191     }
07192     setup_array_1d_d( &arg7, jydata, Alen );
07193     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg7, jydata, 0 );
07194   }
07195   {
07196     if ( jarg8 != NULL )
07197     {
07198       jboolean *jydata = ( *jenv )->GetBooleanArrayElements( jenv, jarg8, 0 );
07199       if ( ( *jenv )->GetArrayLength( jenv, jarg8 ) < Alen - 1 )
07200       {
07201         printf( "Vector must be at least length of others minus 1.\n" );
07202         return;
07203       }
07204       setup_array_1d_b( &arg8, jydata, Alen );
07205       ( *jenv )->ReleaseBooleanArrayElements( jenv, jarg8, jydata, 0 );
07206     }
07207     else
07208     {
07209       arg8 = NULL;
07210     }
07211   }
07212   plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
07213   {
07214     free( arg3 );
07215   }
07216   {
07217     free( arg4 );
07218   }
07219   {
07220     free( arg5 );
07221   }
07222   {
07223     free( arg6 );
07224   }
07225   {
07226     free( arg7 );
07227   }
07228   {
07229     if ( arg8 != NULL )
07230     free( arg8 );
07231   }
07232 }
07233 
07234 
07235 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscmap1n(JNIEnv *jenv, jclass jcls, jint jarg1) {
07236   PLINT arg1 ;
07237   
07238   (void)jenv;
07239   (void)jcls;
07240   arg1 = (PLINT)jarg1; 
07241   plscmap1n(arg1);
07242 }
07243 
07244 
07245 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscol0(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3, jint jarg4) {
07246   PLINT arg1 ;
07247   PLINT arg2 ;
07248   PLINT arg3 ;
07249   PLINT arg4 ;
07250   
07251   (void)jenv;
07252   (void)jcls;
07253   arg1 = (PLINT)jarg1; 
07254   arg2 = (PLINT)jarg2; 
07255   arg3 = (PLINT)jarg3; 
07256   arg4 = (PLINT)jarg4; 
07257   plscol0(arg1,arg2,arg3,arg4);
07258 }
07259 
07260 
07261 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscol0a(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3, jint jarg4, jdouble jarg5) {
07262   PLINT arg1 ;
07263   PLINT arg2 ;
07264   PLINT arg3 ;
07265   PLINT arg4 ;
07266   PLFLT arg5 ;
07267   
07268   (void)jenv;
07269   (void)jcls;
07270   arg1 = (PLINT)jarg1; 
07271   arg2 = (PLINT)jarg2; 
07272   arg3 = (PLINT)jarg3; 
07273   arg4 = (PLINT)jarg4; 
07274   arg5 = (PLFLT)jarg5; 
07275   plscol0a(arg1,arg2,arg3,arg4,arg5);
07276 }
07277 
07278 
07279 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscolbg(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3) {
07280   PLINT arg1 ;
07281   PLINT arg2 ;
07282   PLINT arg3 ;
07283   
07284   (void)jenv;
07285   (void)jcls;
07286   arg1 = (PLINT)jarg1; 
07287   arg2 = (PLINT)jarg2; 
07288   arg3 = (PLINT)jarg3; 
07289   plscolbg(arg1,arg2,arg3);
07290 }
07291 
07292 
07293 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscolbga(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3, jdouble jarg4) {
07294   PLINT arg1 ;
07295   PLINT arg2 ;
07296   PLINT arg3 ;
07297   PLFLT arg4 ;
07298   
07299   (void)jenv;
07300   (void)jcls;
07301   arg1 = (PLINT)jarg1; 
07302   arg2 = (PLINT)jarg2; 
07303   arg3 = (PLINT)jarg3; 
07304   arg4 = (PLFLT)jarg4; 
07305   plscolbga(arg1,arg2,arg3,arg4);
07306 }
07307 
07308 
07309 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscolor(JNIEnv *jenv, jclass jcls, jint jarg1) {
07310   PLINT arg1 ;
07311   
07312   (void)jenv;
07313   (void)jcls;
07314   arg1 = (PLINT)jarg1; 
07315   plscolor(arg1);
07316 }
07317 
07318 
07319 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscompression(JNIEnv *jenv, jclass jcls, jint jarg1) {
07320   PLINT arg1 ;
07321   
07322   (void)jenv;
07323   (void)jcls;
07324   arg1 = (PLINT)jarg1; 
07325   plscompression(arg1);
07326 }
07327 
07328 
07329 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsdev(JNIEnv *jenv, jclass jcls, jstring jarg1) {
07330   char *arg1 = (char *) 0 ;
07331   
07332   (void)jenv;
07333   (void)jcls;
07334   arg1 = 0;
07335   if (jarg1) {
07336     arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
07337     if (!arg1) return ;
07338   }
07339   plsdev((char const *)arg1);
07340   if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
07341 }
07342 
07343 
07344 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsdidev(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4) {
07345   PLFLT arg1 ;
07346   PLFLT arg2 ;
07347   PLFLT arg3 ;
07348   PLFLT arg4 ;
07349   
07350   (void)jenv;
07351   (void)jcls;
07352   arg1 = (PLFLT)jarg1; 
07353   arg2 = (PLFLT)jarg2; 
07354   arg3 = (PLFLT)jarg3; 
07355   arg4 = (PLFLT)jarg4; 
07356   plsdidev(arg1,arg2,arg3,arg4);
07357 }
07358 
07359 
07360 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsdimap(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3, jint jarg4, jdouble jarg5, jdouble jarg6) {
07361   PLINT arg1 ;
07362   PLINT arg2 ;
07363   PLINT arg3 ;
07364   PLINT arg4 ;
07365   PLFLT arg5 ;
07366   PLFLT arg6 ;
07367   
07368   (void)jenv;
07369   (void)jcls;
07370   arg1 = (PLINT)jarg1; 
07371   arg2 = (PLINT)jarg2; 
07372   arg3 = (PLINT)jarg3; 
07373   arg4 = (PLINT)jarg4; 
07374   arg5 = (PLFLT)jarg5; 
07375   arg6 = (PLFLT)jarg6; 
07376   plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
07377 }
07378 
07379 
07380 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsdiori(JNIEnv *jenv, jclass jcls, jdouble jarg1) {
07381   PLFLT arg1 ;
07382   
07383   (void)jenv;
07384   (void)jcls;
07385   arg1 = (PLFLT)jarg1; 
07386   plsdiori(arg1);
07387 }
07388 
07389 
07390 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsdiplt(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4) {
07391   PLFLT arg1 ;
07392   PLFLT arg2 ;
07393   PLFLT arg3 ;
07394   PLFLT arg4 ;
07395   
07396   (void)jenv;
07397   (void)jcls;
07398   arg1 = (PLFLT)jarg1; 
07399   arg2 = (PLFLT)jarg2; 
07400   arg3 = (PLFLT)jarg3; 
07401   arg4 = (PLFLT)jarg4; 
07402   plsdiplt(arg1,arg2,arg3,arg4);
07403 }
07404 
07405 
07406 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsdiplz(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4) {
07407   PLFLT arg1 ;
07408   PLFLT arg2 ;
07409   PLFLT arg3 ;
07410   PLFLT arg4 ;
07411   
07412   (void)jenv;
07413   (void)jcls;
07414   arg1 = (PLFLT)jarg1; 
07415   arg2 = (PLFLT)jarg2; 
07416   arg3 = (PLFLT)jarg3; 
07417   arg4 = (PLFLT)jarg4; 
07418   plsdiplz(arg1,arg2,arg3,arg4);
07419 }
07420 
07421 
07422 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plseed(JNIEnv *jenv, jclass jcls, jlong jarg1) {
07423   unsigned int arg1 ;
07424   
07425   (void)jenv;
07426   (void)jcls;
07427   arg1 = (unsigned int)jarg1; 
07428   plseed(arg1);
07429 }
07430 
07431 
07432 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsesc(JNIEnv *jenv, jclass jcls, jchar jarg1) {
07433   char arg1 ;
07434   
07435   (void)jenv;
07436   (void)jcls;
07437   arg1 = (char)jarg1; 
07438   plsesc(arg1);
07439 }
07440 
07441 
07442 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_plsetopt(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
07443   jint jresult = 0 ;
07444   char *arg1 = (char *) 0 ;
07445   char *arg2 = (char *) 0 ;
07446   PLINT result;
07447   
07448   (void)jenv;
07449   (void)jcls;
07450   arg1 = 0;
07451   if (jarg1) {
07452     arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
07453     if (!arg1) return 0;
07454   }
07455   arg2 = 0;
07456   if (jarg2) {
07457     arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);
07458     if (!arg2) return 0;
07459   }
07460   result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
07461   jresult = (jint)result; 
07462   if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
07463   if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2);
07464   return jresult;
07465 }
07466 
07467 
07468 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsfam(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3) {
07469   PLINT arg1 ;
07470   PLINT arg2 ;
07471   PLINT arg3 ;
07472   
07473   (void)jenv;
07474   (void)jcls;
07475   arg1 = (PLINT)jarg1; 
07476   arg2 = (PLINT)jarg2; 
07477   arg3 = (PLINT)jarg3; 
07478   plsfam(arg1,arg2,arg3);
07479 }
07480 
07481 
07482 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsfci(JNIEnv *jenv, jclass jcls, jlong jarg1) {
07483   PLUNICODE arg1 ;
07484   
07485   (void)jenv;
07486   (void)jcls;
07487   arg1 = (PLUNICODE)jarg1; 
07488   plsfci(arg1);
07489 }
07490 
07491 
07492 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsfnam(JNIEnv *jenv, jclass jcls, jstring jarg1) {
07493   char *arg1 = (char *) 0 ;
07494   
07495   (void)jenv;
07496   (void)jcls;
07497   arg1 = 0;
07498   if (jarg1) {
07499     arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
07500     if (!arg1) return ;
07501   }
07502   plsfnam((char const *)arg1);
07503   if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
07504 }
07505 
07506 
07507 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsfont(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3) {
07508   PLINT arg1 ;
07509   PLINT arg2 ;
07510   PLINT arg3 ;
07511   
07512   (void)jenv;
07513   (void)jcls;
07514   arg1 = (PLINT)jarg1; 
07515   arg2 = (PLINT)jarg2; 
07516   arg3 = (PLINT)jarg3; 
07517   plsfont(arg1,arg2,arg3);
07518 }
07519 
07520 
07521 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plshades(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jdouble jarg5, jdouble jarg6, jdouble jarg7, jdouble jarg8, jdoubleArray jarg9, jint jarg11, jint jarg12, jint jarg13, jboolean jarg15, jobjectArray jarg16, jobjectArray jarg17) {
07522   PLFLT **arg1 = (PLFLT **) 0 ;
07523   PLINT arg2 ;
07524   PLINT arg3 ;
07525   defined_func arg4 ;
07526   PLFLT arg5 ;
07527   PLFLT arg6 ;
07528   PLFLT arg7 ;
07529   PLFLT arg8 ;
07530   PLFLT *arg9 = (PLFLT *) 0 ;
07531   PLINT arg10 ;
07532   PLINT arg11 ;
07533   PLINT arg12 ;
07534   PLINT arg13 ;
07535   fill_func arg14 ;
07536   PLBOOL arg15 ;
07537   pltr_func arg16 ;
07538   PLPointer arg17 = (PLPointer) 0 ;
07539   
07540   (void)jenv;
07541   (void)jcls;
07542   {
07543     arg4 = NULL;
07544   }
07545   {
07546     arg14 = plfill;
07547   }
07548   {
07549     jdouble  **adat;
07550     jobject *ai;
07551     int     nx = ( *jenv )->GetArrayLength( jenv, jarg1 );
07552     int     ny = -1;
07553     int     i, j;
07554     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
07555     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
07556     
07557     ( *jenv )->EnsureLocalCapacity( jenv, nx );
07558     
07559     for ( i = 0; i < nx; i++ )
07560     {
07561       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg1, i );
07562       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
07563       
07564       if ( ny == -1 )
07565       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
07566       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
07567       {
07568         printf( "Misshapen a array.\n" );
07569         for ( j = 0; j <= i; j++ )
07570         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
07571         free( adat );
07572         free( ai );
07573         return;
07574       }
07575     }
07576     
07577     Xlen = nx;
07578     Ylen = ny;
07579     setup_array_2d_d( &arg1, adat, nx, ny );
07580     arg2 = nx;
07581     arg3 = ny;
07582     for ( i = 0; i < nx; i++ )
07583     {
07584       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
07585       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
07586     }
07587     
07588     free( adat );
07589     free( ai );
07590   }
07591   arg5 = (PLFLT)jarg5; 
07592   arg6 = (PLFLT)jarg6; 
07593   arg7 = (PLFLT)jarg7; 
07594   arg8 = (PLFLT)jarg8; 
07595   {
07596     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg9, 0 );
07597     arg10 = ( *jenv )->GetArrayLength( jenv, jarg9 );
07598     setup_array_1d_d( &arg9, jxdata, arg10 );
07599     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg9, jxdata, 0 );
07600   }
07601   arg11 = (PLINT)jarg11; 
07602   arg12 = (PLINT)jarg12; 
07603   arg13 = (PLINT)jarg13; 
07604   
07605   arg15 = jarg15 ? 1 : 0;
07606   
07607   {
07608     jdouble  **adat;
07609     jobject *ai;
07610     int     nx = ( *jenv )->GetArrayLength( jenv, jarg16 );
07611     int     ny = -1;
07612     int     i, j;
07613     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
07614     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
07615     
07616     ( *jenv )->EnsureLocalCapacity( jenv, nx );
07617     
07618     for ( i = 0; i < nx; i++ )
07619     {
07620       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg16, i );
07621       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
07622       
07623       if ( ny == -1 )
07624       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
07625       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
07626       {
07627         printf( "Misshapen a array.\n" );
07628         for ( j = 0; j <= i; j++ )
07629         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
07630         free( adat );
07631         free( ai );
07632         return;
07633       }
07634     }
07635     
07636     if ( !( ( nx == Xlen && ny == Ylen ) || ( nx == Xlen && ny == 1 ) ) )
07637     {
07638       printf( "Xlen =%d, nx =%d, Ylen =%d, ny =%d\n", Xlen, nx, Ylen, ny );
07639       printf( "X vector or matrix must match matrix dimensions.\n" );
07640       for ( i = 0; i < nx; i++ )
07641       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
07642       free( adat );
07643       free( ai );
07644       return;
07645     }
07646     // Store whether second dimension is unity.
07647     Alen = ny;
07648     setup_array_2d_d( &xg, adat, nx, ny );
07649     for ( i = 0; i < nx; i++ )
07650     {
07651       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
07652       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
07653     }
07654     
07655     free( adat );
07656     free( ai );
07657     arg16 = pltr2;
07658   }
07659   {
07660     jdouble   **adat;
07661     jobject  *ai;
07662     int      nx = ( *jenv )->GetArrayLength( jenv, jarg17 );
07663     int      ny = -1;
07664     int      i, j;
07665     PLcGrid2 cgrid;
07666     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
07667     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
07668     
07669     ( *jenv )->EnsureLocalCapacity( jenv, nx );
07670     
07671     for ( i = 0; i < nx; i++ )
07672     {
07673       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg17, i );
07674       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
07675       
07676       if ( ny == -1 )
07677       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
07678       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
07679       {
07680         printf( "Misshapen a array.\n" );
07681         for ( j = 0; j <= i; j++ )
07682         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
07683         free( adat );
07684         free( ai );
07685         return;
07686       }
07687     }
07688     
07689     if ( !( ( nx == Xlen && ny == Ylen ) || ( nx == Ylen && ny == 1 && ny == Alen ) ) )
07690     {
07691       printf( "Xlen =%d, nx =%d, Ylen =%d, Alen =%d, ny =%d\n",
07692         Xlen, nx, Ylen, Alen, ny );
07693       printf( "Y vector or matrix must match matrix dimensions.\n" );
07694       for ( i = 0; i < nx; i++ )
07695       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
07696       free( adat );
07697       free( ai );
07698       return;
07699     }
07700     setup_array_2d_d( &yg, adat, nx, ny );
07701     for ( i = 0; i < nx; i++ )
07702     {
07703       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
07704       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
07705     }
07706     
07707     free( adat );
07708     free( ai );
07709     cgrid.xg = xg;
07710     cgrid.yg = yg;
07711     cgrid.nx = nx;
07712     cgrid.ny = ny;
07713     arg17       = &cgrid;
07714   }
07715   plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
07716   {
07717     free( arg1[0] );
07718     free( arg1 );
07719   }
07720   {
07721     free( arg9 );
07722   }
07723   {
07724     free( xg[0] );
07725     free( xg );
07726   }
07727   {
07728     free( yg[0] );
07729     free( yg );
07730   }
07731 }
07732 
07733 
07734 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plshade(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jdouble jarg5, jdouble jarg6, jdouble jarg7, jdouble jarg8, jdouble jarg9, jdouble jarg10, jint jarg11, jdouble jarg12, jint jarg13, jint jarg14, jint jarg15, jint jarg16, jint jarg17, jboolean jarg19, jobjectArray jarg20, jobjectArray jarg21) {
07735   PLFLT **arg1 = (PLFLT **) 0 ;
07736   PLINT arg2 ;
07737   PLINT arg3 ;
07738   defined_func arg4 ;
07739   PLFLT arg5 ;
07740   PLFLT arg6 ;
07741   PLFLT arg7 ;
07742   PLFLT arg8 ;
07743   PLFLT arg9 ;
07744   PLFLT arg10 ;
07745   PLINT arg11 ;
07746   PLFLT arg12 ;
07747   PLINT arg13 ;
07748   PLINT arg14 ;
07749   PLINT arg15 ;
07750   PLINT arg16 ;
07751   PLINT arg17 ;
07752   fill_func arg18 ;
07753   PLBOOL arg19 ;
07754   pltr_func arg20 ;
07755   PLPointer arg21 = (PLPointer) 0 ;
07756   
07757   (void)jenv;
07758   (void)jcls;
07759   {
07760     arg4 = NULL;
07761   }
07762   {
07763     arg18 = plfill;
07764   }
07765   {
07766     jdouble  **adat;
07767     jobject *ai;
07768     int     nx = ( *jenv )->GetArrayLength( jenv, jarg1 );
07769     int     ny = -1;
07770     int     i, j;
07771     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
07772     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
07773     
07774     ( *jenv )->EnsureLocalCapacity( jenv, nx );
07775     
07776     for ( i = 0; i < nx; i++ )
07777     {
07778       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg1, i );
07779       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
07780       
07781       if ( ny == -1 )
07782       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
07783       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
07784       {
07785         printf( "Misshapen a array.\n" );
07786         for ( j = 0; j <= i; j++ )
07787         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
07788         free( adat );
07789         free( ai );
07790         return;
07791       }
07792     }
07793     
07794     Xlen = nx;
07795     Ylen = ny;
07796     setup_array_2d_d( &arg1, adat, nx, ny );
07797     arg2 = nx;
07798     arg3 = ny;
07799     for ( i = 0; i < nx; i++ )
07800     {
07801       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
07802       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
07803     }
07804     
07805     free( adat );
07806     free( ai );
07807   }
07808   arg5 = (PLFLT)jarg5; 
07809   arg6 = (PLFLT)jarg6; 
07810   arg7 = (PLFLT)jarg7; 
07811   arg8 = (PLFLT)jarg8; 
07812   arg9 = (PLFLT)jarg9; 
07813   arg10 = (PLFLT)jarg10; 
07814   arg11 = (PLINT)jarg11; 
07815   arg12 = (PLFLT)jarg12; 
07816   arg13 = (PLINT)jarg13; 
07817   arg14 = (PLINT)jarg14; 
07818   arg15 = (PLINT)jarg15; 
07819   arg16 = (PLINT)jarg16; 
07820   arg17 = (PLINT)jarg17; 
07821   
07822   arg19 = jarg19 ? 1 : 0;
07823   
07824   {
07825     jdouble  **adat;
07826     jobject *ai;
07827     int     nx = ( *jenv )->GetArrayLength( jenv, jarg20 );
07828     int     ny = -1;
07829     int     i, j;
07830     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
07831     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
07832     
07833     ( *jenv )->EnsureLocalCapacity( jenv, nx );
07834     
07835     for ( i = 0; i < nx; i++ )
07836     {
07837       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg20, i );
07838       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
07839       
07840       if ( ny == -1 )
07841       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
07842       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
07843       {
07844         printf( "Misshapen a array.\n" );
07845         for ( j = 0; j <= i; j++ )
07846         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
07847         free( adat );
07848         free( ai );
07849         return;
07850       }
07851     }
07852     
07853     if ( !( ( nx == Xlen && ny == Ylen ) || ( nx == Xlen && ny == 1 ) ) )
07854     {
07855       printf( "Xlen =%d, nx =%d, Ylen =%d, ny =%d\n", Xlen, nx, Ylen, ny );
07856       printf( "X vector or matrix must match matrix dimensions.\n" );
07857       for ( i = 0; i < nx; i++ )
07858       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
07859       free( adat );
07860       free( ai );
07861       return;
07862     }
07863     // Store whether second dimension is unity.
07864     Alen = ny;
07865     setup_array_2d_d( &xg, adat, nx, ny );
07866     for ( i = 0; i < nx; i++ )
07867     {
07868       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
07869       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
07870     }
07871     
07872     free( adat );
07873     free( ai );
07874     arg20 = pltr2;
07875   }
07876   {
07877     jdouble   **adat;
07878     jobject  *ai;
07879     int      nx = ( *jenv )->GetArrayLength( jenv, jarg21 );
07880     int      ny = -1;
07881     int      i, j;
07882     PLcGrid2 cgrid;
07883     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
07884     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
07885     
07886     ( *jenv )->EnsureLocalCapacity( jenv, nx );
07887     
07888     for ( i = 0; i < nx; i++ )
07889     {
07890       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg21, i );
07891       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
07892       
07893       if ( ny == -1 )
07894       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
07895       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
07896       {
07897         printf( "Misshapen a array.\n" );
07898         for ( j = 0; j <= i; j++ )
07899         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
07900         free( adat );
07901         free( ai );
07902         return;
07903       }
07904     }
07905     
07906     if ( !( ( nx == Xlen && ny == Ylen ) || ( nx == Ylen && ny == 1 && ny == Alen ) ) )
07907     {
07908       printf( "Xlen =%d, nx =%d, Ylen =%d, Alen =%d, ny =%d\n",
07909         Xlen, nx, Ylen, Alen, ny );
07910       printf( "Y vector or matrix must match matrix dimensions.\n" );
07911       for ( i = 0; i < nx; i++ )
07912       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
07913       free( adat );
07914       free( ai );
07915       return;
07916     }
07917     setup_array_2d_d( &yg, adat, nx, ny );
07918     for ( i = 0; i < nx; i++ )
07919     {
07920       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
07921       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
07922     }
07923     
07924     free( adat );
07925     free( ai );
07926     cgrid.xg = xg;
07927     cgrid.yg = yg;
07928     cgrid.nx = nx;
07929     cgrid.ny = ny;
07930     arg21       = &cgrid;
07931   }
07932   plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
07933   {
07934     free( arg1[0] );
07935     free( arg1 );
07936   }
07937   {
07938     free( xg[0] );
07939     free( xg );
07940   }
07941   {
07942     free( yg[0] );
07943     free( yg );
07944   }
07945 }
07946 
07947 
07948 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plslabelfunc(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) {
07949   label_func arg1 ;
07950   PLPointer arg2 = (PLPointer) 0 ;
07951   
07952   (void)jenv;
07953   (void)jcls;
07954   {
07955     jobject obj = jarg1;
07956     
07957     // Delete any old references
07958     if ( labelClass != 0 )
07959     {
07960       ( *jenv )->DeleteGlobalRef( jenv, labelClass );
07961       labelClass = 0;
07962     }
07963     // Need a reference to this object to ensure it is
07964     // valid when we reach the callback
07965     if ( obj != NULL )
07966     {
07967       labelClass = ( *jenv )->NewGlobalRef( jenv, obj );
07968     }
07969     if ( labelClass != 0 )
07970     {
07971       arg1 = label_java;
07972     }
07973     else
07974     {
07975       arg1 = NULL;
07976     }
07977   }
07978   {
07979     arg2 = NULL;
07980   }
07981   plslabelfunc(arg1,arg2);
07982 }
07983 
07984 
07985 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsmaj(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2) {
07986   PLFLT arg1 ;
07987   PLFLT arg2 ;
07988   
07989   (void)jenv;
07990   (void)jcls;
07991   arg1 = (PLFLT)jarg1; 
07992   arg2 = (PLFLT)jarg2; 
07993   plsmaj(arg1,arg2);
07994 }
07995 
07996 
07997 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsmin(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2) {
07998   PLFLT arg1 ;
07999   PLFLT arg2 ;
08000   
08001   (void)jenv;
08002   (void)jcls;
08003   arg1 = (PLFLT)jarg1; 
08004   arg2 = (PLFLT)jarg2; 
08005   plsmin(arg1,arg2);
08006 }
08007 
08008 
08009 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsori(JNIEnv *jenv, jclass jcls, jint jarg1) {
08010   PLINT arg1 ;
08011   
08012   (void)jenv;
08013   (void)jcls;
08014   arg1 = (PLINT)jarg1; 
08015   plsori(arg1);
08016 }
08017 
08018 
08019 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plspage(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6) {
08020   PLFLT arg1 ;
08021   PLFLT arg2 ;
08022   PLINT arg3 ;
08023   PLINT arg4 ;
08024   PLINT arg5 ;
08025   PLINT arg6 ;
08026   
08027   (void)jenv;
08028   (void)jcls;
08029   arg1 = (PLFLT)jarg1; 
08030   arg2 = (PLFLT)jarg2; 
08031   arg3 = (PLINT)jarg3; 
08032   arg4 = (PLINT)jarg4; 
08033   arg5 = (PLINT)jarg5; 
08034   arg6 = (PLINT)jarg6; 
08035   plspage(arg1,arg2,arg3,arg4,arg5,arg6);
08036 }
08037 
08038 
08039 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plspal0(JNIEnv *jenv, jclass jcls, jstring jarg1) {
08040   char *arg1 = (char *) 0 ;
08041   
08042   (void)jenv;
08043   (void)jcls;
08044   arg1 = 0;
08045   if (jarg1) {
08046     arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
08047     if (!arg1) return ;
08048   }
08049   plspal0((char const *)arg1);
08050   if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
08051 }
08052 
08053 
08054 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plspal1(JNIEnv *jenv, jclass jcls, jstring jarg1, jboolean jarg2) {
08055   char *arg1 = (char *) 0 ;
08056   PLBOOL arg2 ;
08057   
08058   (void)jenv;
08059   (void)jcls;
08060   arg1 = 0;
08061   if (jarg1) {
08062     arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
08063     if (!arg1) return ;
08064   }
08065   
08066   arg2 = jarg2 ? 1 : 0;
08067   
08068   plspal1((char const *)arg1,arg2);
08069   if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
08070 }
08071 
08072 
08073 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plspause(JNIEnv *jenv, jclass jcls, jboolean jarg1) {
08074   PLBOOL arg1 ;
08075   
08076   (void)jenv;
08077   (void)jcls;
08078   
08079   arg1 = jarg1 ? 1 : 0;
08080   
08081   plspause(arg1);
08082 }
08083 
08084 
08085 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsstrm(JNIEnv *jenv, jclass jcls, jint jarg1) {
08086   PLINT arg1 ;
08087   
08088   (void)jenv;
08089   (void)jcls;
08090   arg1 = (PLINT)jarg1; 
08091   plsstrm(arg1);
08092 }
08093 
08094 
08095 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plssub(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {
08096   PLINT arg1 ;
08097   PLINT arg2 ;
08098   
08099   (void)jenv;
08100   (void)jcls;
08101   arg1 = (PLINT)jarg1; 
08102   arg2 = (PLINT)jarg2; 
08103   plssub(arg1,arg2);
08104 }
08105 
08106 
08107 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plssym(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2) {
08108   PLFLT arg1 ;
08109   PLFLT arg2 ;
08110   
08111   (void)jenv;
08112   (void)jcls;
08113   arg1 = (PLFLT)jarg1; 
08114   arg2 = (PLFLT)jarg2; 
08115   plssym(arg1,arg2);
08116 }
08117 
08118 
08119 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstar(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {
08120   PLINT arg1 ;
08121   PLINT arg2 ;
08122   
08123   (void)jenv;
08124   (void)jcls;
08125   arg1 = (PLINT)jarg1; 
08126   arg2 = (PLINT)jarg2; 
08127   plstar(arg1,arg2);
08128 }
08129 
08130 
08131 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstart(JNIEnv *jenv, jclass jcls, jstring jarg1, jint jarg2, jint jarg3) {
08132   char *arg1 = (char *) 0 ;
08133   PLINT arg2 ;
08134   PLINT arg3 ;
08135   
08136   (void)jenv;
08137   (void)jcls;
08138   arg1 = 0;
08139   if (jarg1) {
08140     arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
08141     if (!arg1) return ;
08142   }
08143   arg2 = (PLINT)jarg2; 
08144   arg3 = (PLINT)jarg3; 
08145   plstart((char const *)arg1,arg2,arg3);
08146   if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
08147 }
08148 
08149 
08150 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstransform(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) {
08151   ct_func arg1 ;
08152   PLPointer arg2 = (PLPointer) 0 ;
08153   
08154   (void)jenv;
08155   (void)jcls;
08156   {
08157     jobject obj = jarg1;
08158     
08159     // Delete any old references
08160     if ( ctClass != 0 )
08161     {
08162       ( *jenv )->DeleteGlobalRef( jenv, ctClass );
08163       ctClass = 0;
08164     }
08165     // Need a reference to this object to ensure it is
08166     // valid when we reach the callback
08167     if ( obj != NULL )
08168     {
08169       ctClass = ( *jenv )->NewGlobalRef( jenv, obj );
08170     }
08171     if ( ctClass != 0 )
08172     {
08173       arg1 = ct_java;
08174     }
08175     else
08176     {
08177       arg1 = NULL;
08178     }
08179   }
08180   {
08181     arg2 = NULL;
08182   }
08183   plstransform(arg1,arg2);
08184 }
08185 
08186 
08187 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstring(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jstring jarg4) {
08188   PLINT arg1 ;
08189   PLFLT *arg2 = (PLFLT *) 0 ;
08190   PLFLT *arg3 = (PLFLT *) 0 ;
08191   char *arg4 = (char *) 0 ;
08192   
08193   (void)jenv;
08194   (void)jcls;
08195   {
08196     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
08197     arg1   = ( *jenv )->GetArrayLength( jenv, jarg1 );
08198     Alen = arg1;
08199     setup_array_1d_d( &arg2, jxdata, Alen );
08200     // Could find no easy way to do this as part of freearg so I modified
08201     // the previous function so it ALWAYS mallocs and copies so that
08202     // the java array can be released immediately.
08203     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
08204   }
08205   {
08206     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
08207     if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
08208     {
08209       printf( "Vectors must be same length.\n" );
08210       return;
08211     }
08212     setup_array_1d_d( &arg3, jydata, Alen );
08213     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
08214   }
08215   arg4 = 0;
08216   if (jarg4) {
08217     arg4 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg4, 0);
08218     if (!arg4) return ;
08219   }
08220   plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
08221   {
08222     free( arg2 );
08223   }
08224   {
08225     free( arg3 );
08226   }
08227   if (arg4) (*jenv)->ReleaseStringUTFChars(jenv, jarg4, (const char *)arg4);
08228 }
08229 
08230 
08231 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstring3(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jdoubleArray jarg4, jstring jarg5) {
08232   PLINT arg1 ;
08233   PLFLT *arg2 = (PLFLT *) 0 ;
08234   PLFLT *arg3 = (PLFLT *) 0 ;
08235   PLFLT *arg4 = (PLFLT *) 0 ;
08236   char *arg5 = (char *) 0 ;
08237   
08238   (void)jenv;
08239   (void)jcls;
08240   {
08241     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
08242     arg1   = ( *jenv )->GetArrayLength( jenv, jarg1 );
08243     Alen = arg1;
08244     setup_array_1d_d( &arg2, jxdata, Alen );
08245     // Could find no easy way to do this as part of freearg so I modified
08246     // the previous function so it ALWAYS mallocs and copies so that
08247     // the java array can be released immediately.
08248     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
08249   }
08250   {
08251     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
08252     if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
08253     {
08254       printf( "Vectors must be same length.\n" );
08255       return;
08256     }
08257     setup_array_1d_d( &arg3, jydata, Alen );
08258     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
08259   }
08260   {
08261     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg4, 0 );
08262     if ( ( *jenv )->GetArrayLength( jenv, jarg4 ) != Alen )
08263     {
08264       printf( "Vectors must be same length.\n" );
08265       return;
08266     }
08267     setup_array_1d_d( &arg4, jydata, Alen );
08268     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );
08269   }
08270   arg5 = 0;
08271   if (jarg5) {
08272     arg5 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg5, 0);
08273     if (!arg5) return ;
08274   }
08275   plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
08276   {
08277     free( arg2 );
08278   }
08279   {
08280     free( arg3 );
08281   }
08282   {
08283     free( arg4 );
08284   }
08285   if (arg5) (*jenv)->ReleaseStringUTFChars(jenv, jarg5, (const char *)arg5);
08286 }
08287 
08288 
08289 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstripa(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jdouble jarg3, jdouble jarg4) {
08290   PLINT arg1 ;
08291   PLINT arg2 ;
08292   PLFLT arg3 ;
08293   PLFLT arg4 ;
08294   
08295   (void)jenv;
08296   (void)jcls;
08297   arg1 = (PLINT)jarg1; 
08298   arg2 = (PLINT)jarg2; 
08299   arg3 = (PLFLT)jarg3; 
08300   arg4 = (PLFLT)jarg4; 
08301   plstripa(arg1,arg2,arg3,arg4);
08302 }
08303 
08304 
08305 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstripc(JNIEnv *jenv, jclass jcls, jintArray jarg1, jstring jarg2, jstring jarg3, jdouble jarg4, jdouble jarg5, jdouble jarg6, jdouble jarg7, jdouble jarg8, jdouble jarg9, jdouble jarg10, jboolean jarg11, jboolean jarg12, jint jarg13, jint jarg14, jintArray jarg15, jintArray jarg16, jobjectArray jarg17, jstring jarg18, jstring jarg19, jstring jarg20) {
08306   PLINT *arg1 = (PLINT *) 0 ;
08307   char *arg2 = (char *) 0 ;
08308   char *arg3 = (char *) 0 ;
08309   PLFLT arg4 ;
08310   PLFLT arg5 ;
08311   PLFLT arg6 ;
08312   PLFLT arg7 ;
08313   PLFLT arg8 ;
08314   PLFLT arg9 ;
08315   PLFLT arg10 ;
08316   PLBOOL arg11 ;
08317   PLBOOL arg12 ;
08318   PLINT arg13 ;
08319   PLINT arg14 ;
08320   PLINT *arg15 = (PLINT *) 0 ;
08321   PLINT *arg16 = (PLINT *) 0 ;
08322   char **arg17 ;
08323   char *arg18 = (char *) 0 ;
08324   char *arg19 = (char *) 0 ;
08325   char *arg20 = (char *) 0 ;
08326   PLINT temp1 ;
08327   
08328   (void)jenv;
08329   (void)jcls;
08330   {
08331     if (!jarg1) {
08332       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
08333       return ;
08334     }
08335     if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
08336       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
08337       return ;
08338     }
08339     arg1 = &temp1; 
08340   }
08341   arg2 = 0;
08342   if (jarg2) {
08343     arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);
08344     if (!arg2) return ;
08345   }
08346   arg3 = 0;
08347   if (jarg3) {
08348     arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0);
08349     if (!arg3) return ;
08350   }
08351   arg4 = (PLFLT)jarg4; 
08352   arg5 = (PLFLT)jarg5; 
08353   arg6 = (PLFLT)jarg6; 
08354   arg7 = (PLFLT)jarg7; 
08355   arg8 = (PLFLT)jarg8; 
08356   arg9 = (PLFLT)jarg9; 
08357   arg10 = (PLFLT)jarg10; 
08358   
08359   arg11 = jarg11 ? 1 : 0;
08360   
08361   
08362   arg12 = jarg12 ? 1 : 0;
08363   
08364   arg13 = (PLINT)jarg13; 
08365   arg14 = (PLINT)jarg14; 
08366   {
08367     jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg15, 0 );
08368     Alen = ( *jenv )->GetArrayLength( jenv, jarg15 );
08369     setup_array_1d_i( &arg15, jydata, Alen );
08370     ( *jenv )->ReleaseIntArrayElements( jenv, jarg15, jydata, 0 );
08371   }
08372   {
08373     jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg16, 0 );
08374     if ( ( *jenv )->GetArrayLength( jenv, jarg16 ) != Alen )
08375     {
08376       printf( "Vectors must be same length.\n" );
08377       return;
08378     }
08379     setup_array_1d_i( &arg16, jydata, Alen );
08380     ( *jenv )->ReleaseIntArrayElements( jenv, jarg16, jydata, 0 );
08381   }
08382   {
08383     int i    = 0;
08384     int size = ( *jenv )->GetArrayLength( jenv, jarg17 );
08385     if ( size != 4 )
08386     {
08387       printf( "legline must be an array of length 4\n" );
08388       return;
08389     }
08390     arg17 = (char **) malloc( 4 * sizeof ( char * ) );
08391     // make a copy of each string
08392     for ( i = 0; i < 4; i++ )
08393     {
08394       jstring    j_string   = (jstring) ( *jenv )->GetObjectArrayElement( jenv, jarg17, i );
08395       const char * c_string = (char *) ( *jenv )->GetStringUTFChars( jenv, j_string, 0 );
08396       arg17[i] = malloc( ( strlen( c_string ) + 1 ) * sizeof ( const char * ) );
08397       strcpy( arg17[i], c_string );
08398       ( *jenv )->ReleaseStringUTFChars( jenv, j_string, c_string );
08399       ( *jenv )->DeleteLocalRef( jenv, j_string );
08400     }
08401   }
08402   arg18 = 0;
08403   if (jarg18) {
08404     arg18 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg18, 0);
08405     if (!arg18) return ;
08406   }
08407   arg19 = 0;
08408   if (jarg19) {
08409     arg19 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg19, 0);
08410     if (!arg19) return ;
08411   }
08412   arg20 = 0;
08413   if (jarg20) {
08414     arg20 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg20, 0);
08415     if (!arg20) return ;
08416   }
08417   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);
08418   {
08419     jint jvalue = (jint)temp1;
08420     (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
08421   }
08422   
08423   if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2);
08424   if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3);
08425   {
08426     free( arg15 );
08427   }
08428   {
08429     free( arg16 );
08430   }
08431   {
08432     int i;
08433     for ( i = 0; i < 4; i++ )
08434     free( arg17[i] );
08435     free( arg17 );
08436   }
08437   if (arg18) (*jenv)->ReleaseStringUTFChars(jenv, jarg18, (const char *)arg18);
08438   if (arg19) (*jenv)->ReleaseStringUTFChars(jenv, jarg19, (const char *)arg19);
08439   if (arg20) (*jenv)->ReleaseStringUTFChars(jenv, jarg20, (const char *)arg20);
08440 }
08441 
08442 
08443 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstripd(JNIEnv *jenv, jclass jcls, jint jarg1) {
08444   PLINT arg1 ;
08445   
08446   (void)jenv;
08447   (void)jcls;
08448   arg1 = (PLINT)jarg1; 
08449   plstripd(arg1);
08450 }
08451 
08452 
08453 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstyl(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg3) {
08454   PLINT arg1 ;
08455   PLINT *arg2 = (PLINT *) 0 ;
08456   PLINT *arg3 = (PLINT *) 0 ;
08457   
08458   (void)jenv;
08459   (void)jcls;
08460   {
08461     jint *jxdata = ( *jenv )->GetIntArrayElements( jenv, jarg1, 0 );
08462     arg1   = ( *jenv )->GetArrayLength( jenv, jarg1 );
08463     Alen = arg1;
08464     setup_array_1d_i( &arg2, jxdata, Alen );
08465     // Could find no easy way to do this as part of freearg so I modified
08466     // the previous function so it ALWAYS mallocs and copies so that
08467     // the java array can be released immediately.
08468     ( *jenv )->ReleaseIntArrayElements( jenv, jarg1, jxdata, 0 );
08469   }
08470   {
08471     jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg3, 0 );
08472     if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
08473     {
08474       printf( "Vectors must be same length.\n" );
08475       return;
08476     }
08477     setup_array_1d_i( &arg3, jydata, Alen );
08478     ( *jenv )->ReleaseIntArrayElements( jenv, jarg3, jydata, 0 );
08479   }
08480   plstyl(arg1,(int const *)arg2,(int const *)arg3);
08481   {
08482     free( arg2 );
08483   }
08484   {
08485     free( arg3 );
08486   }
08487 }
08488 
08489 
08490 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsvect(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jboolean jarg4) {
08491   PLFLT *arg1 = (PLFLT *) 0 ;
08492   PLFLT *arg2 = (PLFLT *) 0 ;
08493   PLINT arg3 ;
08494   PLBOOL arg4 ;
08495   
08496   (void)jenv;
08497   (void)jcls;
08498   {
08499     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
08500     Alen = ( *jenv )->GetArrayLength( jenv, jarg1 );
08501     setup_array_1d_d( &arg1, jxdata, Alen );
08502     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
08503   }
08504   {
08505     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg2, 0 );
08506     arg3 = ( *jenv )->GetArrayLength( jenv, jarg2 );
08507     if ( ( *jenv )->GetArrayLength( jenv, jarg2 ) != Alen )
08508     {
08509       printf( "Vectors must be same length.\n" );
08510       return;
08511     }
08512     setup_array_1d_d( &arg2, jydata, Alen );
08513     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );
08514   }
08515   
08516   arg4 = jarg4 ? 1 : 0;
08517   
08518   plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
08519   {
08520     free( arg1 );
08521   }
08522   {
08523     free( arg2 );
08524   }
08525 }
08526 
08527 
08528 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsvpa(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4) {
08529   PLFLT arg1 ;
08530   PLFLT arg2 ;
08531   PLFLT arg3 ;
08532   PLFLT arg4 ;
08533   
08534   (void)jenv;
08535   (void)jcls;
08536   arg1 = (PLFLT)jarg1; 
08537   arg2 = (PLFLT)jarg2; 
08538   arg3 = (PLFLT)jarg3; 
08539   arg4 = (PLFLT)jarg4; 
08540   plsvpa(arg1,arg2,arg3,arg4);
08541 }
08542 
08543 
08544 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsxax(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {
08545   PLINT arg1 ;
08546   PLINT arg2 ;
08547   
08548   (void)jenv;
08549   (void)jcls;
08550   arg1 = (PLINT)jarg1; 
08551   arg2 = (PLINT)jarg2; 
08552   plsxax(arg1,arg2);
08553 }
08554 
08555 
08556 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsyax(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {
08557   PLINT arg1 ;
08558   PLINT arg2 ;
08559   
08560   (void)jenv;
08561   (void)jcls;
08562   arg1 = (PLINT)jarg1; 
08563   arg2 = (PLINT)jarg2; 
08564   plsyax(arg1,arg2);
08565 }
08566 
08567 
08568 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsym(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jint jarg4) {
08569   PLINT arg1 ;
08570   PLFLT *arg2 = (PLFLT *) 0 ;
08571   PLFLT *arg3 = (PLFLT *) 0 ;
08572   PLINT arg4 ;
08573   
08574   (void)jenv;
08575   (void)jcls;
08576   {
08577     jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
08578     arg1   = ( *jenv )->GetArrayLength( jenv, jarg1 );
08579     Alen = arg1;
08580     setup_array_1d_d( &arg2, jxdata, Alen );
08581     // Could find no easy way to do this as part of freearg so I modified
08582     // the previous function so it ALWAYS mallocs and copies so that
08583     // the java array can be released immediately.
08584     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
08585   }
08586   {
08587     jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
08588     if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
08589     {
08590       printf( "Vectors must be same length.\n" );
08591       return;
08592     }
08593     setup_array_1d_d( &arg3, jydata, Alen );
08594     ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
08595   }
08596   arg4 = (PLINT)jarg4; 
08597   plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
08598   {
08599     free( arg2 );
08600   }
08601   {
08602     free( arg3 );
08603   }
08604 }
08605 
08606 
08607 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plszax(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {
08608   PLINT arg1 ;
08609   PLINT arg2 ;
08610   
08611   (void)jenv;
08612   (void)jcls;
08613   arg1 = (PLINT)jarg1; 
08614   arg2 = (PLINT)jarg2; 
08615   plszax(arg1,arg2);
08616 }
08617 
08618 
08619 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pltext(JNIEnv *jenv, jclass jcls) {
08620   (void)jenv;
08621   (void)jcls;
08622   pltext();
08623 }
08624 
08625 
08626 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pltimefmt(JNIEnv *jenv, jclass jcls, jstring jarg1) {
08627   char *arg1 = (char *) 0 ;
08628   
08629   (void)jenv;
08630   (void)jcls;
08631   arg1 = 0;
08632   if (jarg1) {
08633     arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
08634     if (!arg1) return ;
08635   }
08636   pltimefmt((char const *)arg1);
08637   if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
08638 }
08639 
08640 
08641 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plvasp(JNIEnv *jenv, jclass jcls, jdouble jarg1) {
08642   PLFLT arg1 ;
08643   
08644   (void)jenv;
08645   (void)jcls;
08646   arg1 = (PLFLT)jarg1; 
08647   plvasp(arg1);
08648 }
08649 
08650 
08651 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plvect(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jobjectArray jarg2, jdouble jarg5, jobjectArray jarg6, jobjectArray jarg7) {
08652   PLFLT **arg1 = (PLFLT **) 0 ;
08653   PLFLT **arg2 = (PLFLT **) 0 ;
08654   PLINT arg3 ;
08655   PLINT arg4 ;
08656   PLFLT arg5 ;
08657   pltr_func arg6 ;
08658   PLPointer arg7 = (PLPointer) 0 ;
08659   
08660   (void)jenv;
08661   (void)jcls;
08662   {
08663     jdouble  **adat;
08664     jobject *ai;
08665     int     nx = ( *jenv )->GetArrayLength( jenv, jarg1 );
08666     int     ny = -1;
08667     int     i, j;
08668     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
08669     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
08670     
08671     ( *jenv )->EnsureLocalCapacity( jenv, nx );
08672     
08673     for ( i = 0; i < nx; i++ )
08674     {
08675       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg1, i );
08676       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
08677       
08678       if ( ny == -1 )
08679       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
08680       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
08681       {
08682         printf( "Misshapen a array.\n" );
08683         for ( j = 0; j <= i; j++ )
08684         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
08685         free( adat );
08686         free( ai );
08687         return;
08688       }
08689     }
08690     
08691     Xlen = nx;
08692     Ylen = ny;
08693     setup_array_2d_d( &arg1, adat, nx, ny );
08694     for ( i = 0; i < nx; i++ )
08695     {
08696       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
08697       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
08698     }
08699     
08700     free( adat );
08701     free( ai );
08702   }
08703   {
08704     jdouble  **adat;
08705     jobject *ai;
08706     int     nx = ( *jenv )->GetArrayLength( jenv, jarg2 );
08707     int     ny = -1;
08708     int     i, j;
08709     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
08710     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
08711     
08712     ( *jenv )->EnsureLocalCapacity( jenv, nx );
08713     
08714     for ( i = 0; i < nx; i++ )
08715     {
08716       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg2, i );
08717       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
08718       
08719       if ( ny == -1 )
08720       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
08721       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
08722       {
08723         printf( "Misshapen a array.\n" );
08724         for ( j = 0; j <= i; j++ )
08725         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
08726         free( adat );
08727         free( ai );
08728         return;
08729       }
08730     }
08731     
08732     if ( nx != Xlen || ny != Ylen )
08733     {
08734       printf( "Vectors must match matrix.\n" );
08735       for ( i = 0; i < nx; i++ )
08736       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
08737       free( adat );
08738       free( ai );
08739       return;
08740     }
08741     setup_array_2d_d( &arg2, adat, nx, ny );
08742     arg3 = nx;
08743     arg4 = ny;
08744     for ( i = 0; i < nx; i++ )
08745     {
08746       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
08747       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
08748     }
08749     
08750     
08751     free( adat );
08752     free( ai );
08753   }
08754   arg5 = (PLFLT)jarg5; 
08755   {
08756     jdouble  **adat;
08757     jobject *ai;
08758     int     nx = ( *jenv )->GetArrayLength( jenv, jarg6 );
08759     int     ny = -1;
08760     int     i, j;
08761     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
08762     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
08763     
08764     ( *jenv )->EnsureLocalCapacity( jenv, nx );
08765     
08766     for ( i = 0; i < nx; i++ )
08767     {
08768       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg6, i );
08769       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
08770       
08771       if ( ny == -1 )
08772       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
08773       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
08774       {
08775         printf( "Misshapen a array.\n" );
08776         for ( j = 0; j <= i; j++ )
08777         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
08778         free( adat );
08779         free( ai );
08780         return;
08781       }
08782     }
08783     
08784     if ( !( ( nx == Xlen && ny == Ylen ) || ( nx == Xlen && ny == 1 ) ) )
08785     {
08786       printf( "Xlen =%d, nx =%d, Ylen =%d, ny =%d\n", Xlen, nx, Ylen, ny );
08787       printf( "X vector or matrix must match matrix dimensions.\n" );
08788       for ( i = 0; i < nx; i++ )
08789       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
08790       free( adat );
08791       free( ai );
08792       return;
08793     }
08794     // Store whether second dimension is unity.
08795     Alen = ny;
08796     setup_array_2d_d( &xg, adat, nx, ny );
08797     for ( i = 0; i < nx; i++ )
08798     {
08799       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
08800       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
08801     }
08802     
08803     free( adat );
08804     free( ai );
08805     arg6 = pltr2;
08806   }
08807   {
08808     jdouble   **adat;
08809     jobject  *ai;
08810     int      nx = ( *jenv )->GetArrayLength( jenv, jarg7 );
08811     int      ny = -1;
08812     int      i, j;
08813     PLcGrid2 cgrid;
08814     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
08815     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
08816     
08817     ( *jenv )->EnsureLocalCapacity( jenv, nx );
08818     
08819     for ( i = 0; i < nx; i++ )
08820     {
08821       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg7, i );
08822       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
08823       
08824       if ( ny == -1 )
08825       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
08826       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
08827       {
08828         printf( "Misshapen a array.\n" );
08829         for ( j = 0; j <= i; j++ )
08830         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
08831         free( adat );
08832         free( ai );
08833         return;
08834       }
08835     }
08836     
08837     if ( !( ( nx == Xlen && ny == Ylen ) || ( nx == Ylen && ny == 1 && ny == Alen ) ) )
08838     {
08839       printf( "Xlen =%d, nx =%d, Ylen =%d, Alen =%d, ny =%d\n",
08840         Xlen, nx, Ylen, Alen, ny );
08841       printf( "Y vector or matrix must match matrix dimensions.\n" );
08842       for ( i = 0; i < nx; i++ )
08843       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
08844       free( adat );
08845       free( ai );
08846       return;
08847     }
08848     setup_array_2d_d( &yg, adat, nx, ny );
08849     for ( i = 0; i < nx; i++ )
08850     {
08851       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
08852       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
08853     }
08854     
08855     free( adat );
08856     free( ai );
08857     cgrid.xg = xg;
08858     cgrid.yg = yg;
08859     cgrid.nx = nx;
08860     cgrid.ny = ny;
08861     arg7       = &cgrid;
08862   }
08863   plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
08864   {
08865     free( arg1[0] );
08866     free( arg1 );
08867   }
08868   {
08869     free( arg2[0] );
08870     free( arg2 );
08871   }
08872   {
08873     free( xg[0] );
08874     free( xg );
08875   }
08876   {
08877     free( yg[0] );
08878     free( yg );
08879   }
08880 }
08881 
08882 
08883 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plvpas(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4, jdouble jarg5) {
08884   PLFLT arg1 ;
08885   PLFLT arg2 ;
08886   PLFLT arg3 ;
08887   PLFLT arg4 ;
08888   PLFLT arg5 ;
08889   
08890   (void)jenv;
08891   (void)jcls;
08892   arg1 = (PLFLT)jarg1; 
08893   arg2 = (PLFLT)jarg2; 
08894   arg3 = (PLFLT)jarg3; 
08895   arg4 = (PLFLT)jarg4; 
08896   arg5 = (PLFLT)jarg5; 
08897   plvpas(arg1,arg2,arg3,arg4,arg5);
08898 }
08899 
08900 
08901 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plvpor(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4) {
08902   PLFLT arg1 ;
08903   PLFLT arg2 ;
08904   PLFLT arg3 ;
08905   PLFLT arg4 ;
08906   
08907   (void)jenv;
08908   (void)jcls;
08909   arg1 = (PLFLT)jarg1; 
08910   arg2 = (PLFLT)jarg2; 
08911   arg3 = (PLFLT)jarg3; 
08912   arg4 = (PLFLT)jarg4; 
08913   plvpor(arg1,arg2,arg3,arg4);
08914 }
08915 
08916 
08917 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plvsta(JNIEnv *jenv, jclass jcls) {
08918   (void)jenv;
08919   (void)jcls;
08920   plvsta();
08921 }
08922 
08923 
08924 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plw3d(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4, jdouble jarg5, jdouble jarg6, jdouble jarg7, jdouble jarg8, jdouble jarg9, jdouble jarg10, jdouble jarg11) {
08925   PLFLT arg1 ;
08926   PLFLT arg2 ;
08927   PLFLT arg3 ;
08928   PLFLT arg4 ;
08929   PLFLT arg5 ;
08930   PLFLT arg6 ;
08931   PLFLT arg7 ;
08932   PLFLT arg8 ;
08933   PLFLT arg9 ;
08934   PLFLT arg10 ;
08935   PLFLT arg11 ;
08936   
08937   (void)jenv;
08938   (void)jcls;
08939   arg1 = (PLFLT)jarg1; 
08940   arg2 = (PLFLT)jarg2; 
08941   arg3 = (PLFLT)jarg3; 
08942   arg4 = (PLFLT)jarg4; 
08943   arg5 = (PLFLT)jarg5; 
08944   arg6 = (PLFLT)jarg6; 
08945   arg7 = (PLFLT)jarg7; 
08946   arg8 = (PLFLT)jarg8; 
08947   arg9 = (PLFLT)jarg9; 
08948   arg10 = (PLFLT)jarg10; 
08949   arg11 = (PLFLT)jarg11; 
08950   plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
08951 }
08952 
08953 
08954 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plwid(JNIEnv *jenv, jclass jcls, jint jarg1) {
08955   PLINT arg1 ;
08956   
08957   (void)jenv;
08958   (void)jcls;
08959   arg1 = (PLINT)jarg1; 
08960   plwid(arg1);
08961 }
08962 
08963 
08964 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plwind(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4) {
08965   PLFLT arg1 ;
08966   PLFLT arg2 ;
08967   PLFLT arg3 ;
08968   PLFLT arg4 ;
08969   
08970   (void)jenv;
08971   (void)jcls;
08972   arg1 = (PLFLT)jarg1; 
08973   arg2 = (PLFLT)jarg2; 
08974   arg3 = (PLFLT)jarg3; 
08975   arg4 = (PLFLT)jarg4; 
08976   plwind(arg1,arg2,arg3,arg4);
08977 }
08978 
08979 
08980 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plxormod(JNIEnv *jenv, jclass jcls, jboolean jarg1, 
08981   jbooleanArray
08982   jarg2) {
08983   PLBOOL arg1 ;
08984   PLBOOL *arg2 = (PLBOOL *) 0 ;
08985   PLBOOL temp2 ;
08986   
08987   (void)jenv;
08988   (void)jcls;
08989   
08990   arg1 = jarg1 ? 1 : 0;
08991   
08992   {
08993     if ( !jarg2 )
08994     {
08995       SWIG_JavaThrowException( jenv, SWIG_JavaNullPointerException, "array null" );
08996       return ;
08997     }
08998     if ( (*jenv)->GetArrayLength(jenv, jarg2) == 0 )
08999     {
09000       SWIG_JavaThrowException( jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element" );
09001       return ;
09002     }
09003     arg2 = &temp2;
09004   }
09005   plxormod(arg1,arg2);
09006   {
09007     jboolean jvalue = (jboolean) temp2;
09008     (*jenv)->SetBooleanArrayRegion(jenv, jarg2, 0, 1, &jvalue);
09009   }
09010   
09011 }
09012 
09013 
09014 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plmap(JNIEnv *jenv, jclass jcls, jobject jarg1, jstring jarg2, jdouble jarg3, jdouble jarg4, jdouble jarg5, jdouble jarg6) {
09015   mapform_func arg1 ;
09016   char *arg2 = (char *) 0 ;
09017   PLFLT arg3 ;
09018   PLFLT arg4 ;
09019   PLFLT arg5 ;
09020   PLFLT arg6 ;
09021   
09022   (void)jenv;
09023   (void)jcls;
09024   {
09025     jobject obj = jarg1;
09026     if ( obj != NULL )
09027     {
09028       jclass cls = ( *jenv )->GetObjectClass( jenv, obj );
09029       mapformID    = ( *jenv )->GetMethodID( jenv, cls, "mapform", "([D[D)V" );
09030       mapformClass = obj;
09031       cbenvMapform = jenv;
09032       arg1           = mapform_java;
09033     }
09034     else
09035     {
09036       arg1 = NULL;
09037     }
09038   }
09039   arg2 = 0;
09040   if (jarg2) {
09041     arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);
09042     if (!arg2) return ;
09043   }
09044   arg3 = (PLFLT)jarg3; 
09045   arg4 = (PLFLT)jarg4; 
09046   arg5 = (PLFLT)jarg5; 
09047   arg6 = (PLFLT)jarg6; 
09048   plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
09049   if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2);
09050 }
09051 
09052 
09053 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plmeridians(JNIEnv *jenv, jclass jcls, jobject jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4, jdouble jarg5, jdouble jarg6, jdouble jarg7) {
09054   mapform_func arg1 ;
09055   PLFLT arg2 ;
09056   PLFLT arg3 ;
09057   PLFLT arg4 ;
09058   PLFLT arg5 ;
09059   PLFLT arg6 ;
09060   PLFLT arg7 ;
09061   
09062   (void)jenv;
09063   (void)jcls;
09064   {
09065     jobject obj = jarg1;
09066     if ( obj != NULL )
09067     {
09068       jclass cls = ( *jenv )->GetObjectClass( jenv, obj );
09069       mapformID    = ( *jenv )->GetMethodID( jenv, cls, "mapform", "([D[D)V" );
09070       mapformClass = obj;
09071       cbenvMapform = jenv;
09072       arg1           = mapform_java;
09073     }
09074     else
09075     {
09076       arg1 = NULL;
09077     }
09078   }
09079   arg2 = (PLFLT)jarg2; 
09080   arg3 = (PLFLT)jarg3; 
09081   arg4 = (PLFLT)jarg4; 
09082   arg5 = (PLFLT)jarg5; 
09083   arg6 = (PLFLT)jarg6; 
09084   arg7 = (PLFLT)jarg7; 
09085   plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
09086 }
09087 
09088 
09089 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plimage(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jdouble jarg4, jdouble jarg5, jdouble jarg6, jdouble jarg7, jdouble jarg8, jdouble jarg9, jdouble jarg10, jdouble jarg11, jdouble jarg12, jdouble jarg13) {
09090   PLFLT **arg1 = (PLFLT **) 0 ;
09091   PLINT arg2 ;
09092   PLINT arg3 ;
09093   PLFLT arg4 ;
09094   PLFLT arg5 ;
09095   PLFLT arg6 ;
09096   PLFLT arg7 ;
09097   PLFLT arg8 ;
09098   PLFLT arg9 ;
09099   PLFLT arg10 ;
09100   PLFLT arg11 ;
09101   PLFLT arg12 ;
09102   PLFLT arg13 ;
09103   
09104   (void)jenv;
09105   (void)jcls;
09106   {
09107     jdouble  **adat;
09108     jobject *ai;
09109     int     nx = ( *jenv )->GetArrayLength( jenv, jarg1 );
09110     int     ny = -1;
09111     int     i, j;
09112     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
09113     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
09114     
09115     ( *jenv )->EnsureLocalCapacity( jenv, nx );
09116     
09117     for ( i = 0; i < nx; i++ )
09118     {
09119       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg1, i );
09120       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
09121       
09122       if ( ny == -1 )
09123       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
09124       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
09125       {
09126         printf( "Misshapen a array.\n" );
09127         for ( j = 0; j <= i; j++ )
09128         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
09129         free( adat );
09130         free( ai );
09131         return;
09132       }
09133     }
09134     
09135     Xlen = nx;
09136     Ylen = ny;
09137     setup_array_2d_d( &arg1, adat, nx, ny );
09138     arg2 = nx;
09139     arg3 = ny;
09140     for ( i = 0; i < nx; i++ )
09141     {
09142       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
09143       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
09144     }
09145     
09146     free( adat );
09147     free( ai );
09148   }
09149   arg4 = (PLFLT)jarg4; 
09150   arg5 = (PLFLT)jarg5; 
09151   arg6 = (PLFLT)jarg6; 
09152   arg7 = (PLFLT)jarg7; 
09153   arg8 = (PLFLT)jarg8; 
09154   arg9 = (PLFLT)jarg9; 
09155   arg10 = (PLFLT)jarg10; 
09156   arg11 = (PLFLT)jarg11; 
09157   arg12 = (PLFLT)jarg12; 
09158   arg13 = (PLFLT)jarg13; 
09159   plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
09160   {
09161     free( arg1[0] );
09162     free( arg1 );
09163   }
09164 }
09165 
09166 
09167 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plimagefr(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jdouble jarg4, jdouble jarg5, jdouble jarg6, jdouble jarg7, jdouble jarg8, jdouble jarg9, jdouble jarg10, jdouble jarg11, jobjectArray jarg12, jobjectArray jarg13) {
09168   PLFLT **arg1 = (PLFLT **) 0 ;
09169   PLINT arg2 ;
09170   PLINT arg3 ;
09171   PLFLT arg4 ;
09172   PLFLT arg5 ;
09173   PLFLT arg6 ;
09174   PLFLT arg7 ;
09175   PLFLT arg8 ;
09176   PLFLT arg9 ;
09177   PLFLT arg10 ;
09178   PLFLT arg11 ;
09179   pltr_func arg12 ;
09180   PLPointer arg13 = (PLPointer) 0 ;
09181   
09182   (void)jenv;
09183   (void)jcls;
09184   {
09185     jdouble  **adat;
09186     jobject *ai;
09187     int     nx = ( *jenv )->GetArrayLength( jenv, jarg1 );
09188     int     ny = -1;
09189     int     i, j;
09190     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
09191     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
09192     
09193     ( *jenv )->EnsureLocalCapacity( jenv, nx );
09194     
09195     for ( i = 0; i < nx; i++ )
09196     {
09197       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg1, i );
09198       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
09199       
09200       if ( ny == -1 )
09201       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
09202       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
09203       {
09204         printf( "Misshapen a array.\n" );
09205         for ( j = 0; j <= i; j++ )
09206         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
09207         free( adat );
09208         free( ai );
09209         return;
09210       }
09211     }
09212     
09213     Xlen = nx;
09214     Ylen = ny;
09215     setup_array_2d_d( &arg1, adat, nx, ny );
09216     arg2 = nx;
09217     arg3 = ny;
09218     for ( i = 0; i < nx; i++ )
09219     {
09220       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
09221       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
09222     }
09223     
09224     free( adat );
09225     free( ai );
09226   }
09227   arg4 = (PLFLT)jarg4; 
09228   arg5 = (PLFLT)jarg5; 
09229   arg6 = (PLFLT)jarg6; 
09230   arg7 = (PLFLT)jarg7; 
09231   arg8 = (PLFLT)jarg8; 
09232   arg9 = (PLFLT)jarg9; 
09233   arg10 = (PLFLT)jarg10; 
09234   arg11 = (PLFLT)jarg11; 
09235   {
09236     jdouble  **adat;
09237     jobject *ai;
09238     int     nx = ( *jenv )->GetArrayLength( jenv, jarg12 );
09239     int     ny = -1;
09240     int     i, j;
09241     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
09242     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
09243     
09244     ( *jenv )->EnsureLocalCapacity( jenv, nx );
09245     
09246     for ( i = 0; i < nx; i++ )
09247     {
09248       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg12, i );
09249       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
09250       
09251       if ( ny == -1 )
09252       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
09253       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
09254       {
09255         printf( "Misshapen a array.\n" );
09256         for ( j = 0; j <= i; j++ )
09257         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
09258         free( adat );
09259         free( ai );
09260         return;
09261       }
09262     }
09263     
09264     if ( !( ( nx == Xlen + 1 && ny == Ylen + 1 ) || ( nx == Xlen + 1 && ny == 1 ) ) )
09265     {
09266       printf( "Xlen =%d, nx =%d, Ylen =%d, ny =%d\n", Xlen, nx, Ylen, ny );
09267       printf( "X vector or matrix must match matrix dimensions.\n" );
09268       for ( i = 0; i < nx; i++ )
09269       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
09270       free( adat );
09271       free( ai );
09272       return;
09273     }
09274     // Store whether second dimension is unity.
09275     Alen = ny;
09276     setup_array_2d_d( &xg, adat, nx, ny );
09277     for ( i = 0; i < nx; i++ )
09278     {
09279       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
09280       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
09281     }
09282     
09283     free( adat );
09284     free( ai );
09285     arg12 = pltr2;
09286   }
09287   {
09288     jdouble   **adat;
09289     jobject  *ai;
09290     int      nx = ( *jenv )->GetArrayLength( jenv, jarg13 );
09291     int      ny = -1;
09292     int      i, j;
09293     PLcGrid2 cgrid;
09294     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
09295     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
09296     
09297     ( *jenv )->EnsureLocalCapacity( jenv, nx );
09298     
09299     for ( i = 0; i < nx; i++ )
09300     {
09301       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg13, i );
09302       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
09303       
09304       if ( ny == -1 )
09305       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
09306       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
09307       {
09308         printf( "Misshapen a array.\n" );
09309         for ( j = 0; j <= i; j++ )
09310         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
09311         free( adat );
09312         free( ai );
09313         return;
09314       }
09315     }
09316     
09317     if ( !( ( nx == Xlen + 1 && ny == Ylen + 1 ) || ( nx == Ylen + 1 && ny == 1 && ny == Alen ) ) )
09318     {
09319       printf( "Xlen =%d, nx =%d, Ylen =%d, Alen =%d, ny =%d\n",
09320         Xlen, nx, Ylen, Alen, ny );
09321       printf( "Y vector or matrix must match matrix dimensions.\n" );
09322       for ( i = 0; i < nx; i++ )
09323       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
09324       free( adat );
09325       free( ai );
09326       return;
09327     }
09328     setup_array_2d_d( &yg, adat, nx, ny );
09329     for ( i = 0; i < nx; i++ )
09330     {
09331       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
09332       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
09333     }
09334     
09335     free( adat );
09336     free( ai );
09337     cgrid.xg = xg;
09338     cgrid.yg = yg;
09339     cgrid.nx = nx;
09340     cgrid.ny = ny;
09341     arg13       = &cgrid;
09342   }
09343   plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
09344   {
09345     free( arg1[0] );
09346     free( arg1 );
09347   }
09348   {
09349     free( xg[0] );
09350     free( xg );
09351   }
09352   {
09353     free( yg[0] );
09354     free( yg );
09355   }
09356 }
09357 
09358 
09359 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plClearOpts(JNIEnv *jenv, jclass jcls) {
09360   (void)jenv;
09361   (void)jcls;
09362   plClearOpts();
09363 }
09364 
09365 
09366 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plResetOpts(JNIEnv *jenv, jclass jcls) {
09367   (void)jenv;
09368   (void)jcls;
09369   plResetOpts();
09370 }
09371 
09372 
09373 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plSetUsage(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
09374   char *arg1 = (char *) 0 ;
09375   char *arg2 = (char *) 0 ;
09376   
09377   (void)jenv;
09378   (void)jcls;
09379   arg1 = 0;
09380   if (jarg1) {
09381     arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
09382     if (!arg1) return ;
09383   }
09384   arg2 = 0;
09385   if (jarg2) {
09386     arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);
09387     if (!arg2) return ;
09388   }
09389   plSetUsage((char const *)arg1,(char const *)arg2);
09390   if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
09391   if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2);
09392 }
09393 
09394 
09395 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plOptUsage(JNIEnv *jenv, jclass jcls) {
09396   (void)jenv;
09397   (void)jcls;
09398   plOptUsage();
09399 }
09400 
09401 
09402 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plMinMax2dGrid(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jdoubleArray jarg4, jdoubleArray jarg5) {
09403   PLFLT **arg1 = (PLFLT **) 0 ;
09404   PLINT arg2 ;
09405   PLINT arg3 ;
09406   PLFLT *arg4 = (PLFLT *) 0 ;
09407   PLFLT *arg5 = (PLFLT *) 0 ;
09408   PLFLT temp4 ;
09409   PLFLT temp5 ;
09410   
09411   (void)jenv;
09412   (void)jcls;
09413   {
09414     jdouble  **adat;
09415     jobject *ai;
09416     int     nx = ( *jenv )->GetArrayLength( jenv, jarg1 );
09417     int     ny = -1;
09418     int     i, j;
09419     ai   = (jobject *) malloc( nx * sizeof ( jobject ) );
09420     adat = (jdouble **) malloc( nx * sizeof ( jdouble * ) );
09421     
09422     ( *jenv )->EnsureLocalCapacity( jenv, nx );
09423     
09424     for ( i = 0; i < nx; i++ )
09425     {
09426       ai[i]   = ( *jenv )->GetObjectArrayElement( jenv, jarg1, i );
09427       adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
09428       
09429       if ( ny == -1 )
09430       ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
09431       else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
09432       {
09433         printf( "Misshapen a array.\n" );
09434         for ( j = 0; j <= i; j++ )
09435         ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
09436         free( adat );
09437         free( ai );
09438         return;
09439       }
09440     }
09441     
09442     Xlen = nx;
09443     Ylen = ny;
09444     setup_array_2d_d( &arg1, adat, nx, ny );
09445     arg2 = nx;
09446     arg3 = ny;
09447     for ( i = 0; i < nx; i++ )
09448     {
09449       ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
09450       ( *jenv )->DeleteLocalRef( jenv, ai[i] );
09451     }
09452     
09453     free( adat );
09454     free( ai );
09455   }
09456   {
09457     if (!jarg4) {
09458       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
09459       return ;
09460     }
09461     if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
09462       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
09463       return ;
09464     }
09465     arg4 = &temp4; 
09466   }
09467   {
09468     if (!jarg5) {
09469       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
09470       return ;
09471     }
09472     if ((*jenv)->GetArrayLength(jenv, jarg5) == 0) {
09473       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
09474       return ;
09475     }
09476     arg5 = &temp5; 
09477   }
09478   plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
09479   {
09480     jdouble jvalue = (jdouble)temp4;
09481     (*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);
09482   }
09483   {
09484     jdouble jvalue = (jdouble)temp5;
09485     (*jenv)->SetDoubleArrayRegion(jenv, jarg5, 0, 1, &jvalue);
09486   }
09487   {
09488     free( arg1[0] );
09489     free( arg1 );
09490   }
09491   
09492   
09493 }
09494 
09495 
09496 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_plGetCursor(JNIEnv *jenv, jclass jcls, jlong jarg1) {
09497   jint jresult = 0 ;
09498   PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
09499   PLINT result;
09500   
09501   (void)jenv;
09502   (void)jcls;
09503   arg1 = *(PLGraphicsIn **)&jarg1; 
09504   result = (PLINT)plGetCursor(arg1);
09505   jresult = (jint)result; 
09506   return jresult;
09507 }
09508 
09509 
09510 #ifdef __cplusplus
09511 }
09512 #endif
09513 

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