00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011 #define SWIGJAVA
00012
00013
00014
00015
00016
00017
00018
00019 #ifndef SWIGTEMPLATEDISAMBIGUATOR
00020 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
00021 # define SWIGTEMPLATEDISAMBIGUATOR template
00022 # elif defined(__HP_aCC)
00023
00024
00025 # define SWIGTEMPLATEDISAMBIGUATOR template
00026 # else
00027 # define SWIGTEMPLATEDISAMBIGUATOR
00028 # endif
00029 #endif
00030
00031
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
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)
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
00070 #ifndef SWIGINTERN
00071 # define SWIGINTERN static SWIGUNUSED
00072 #endif
00073
00074
00075 #ifndef SWIGINTERNINLINE
00076 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
00077 #endif
00078
00079
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
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
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
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
00124 #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
00125 typedef long long __int64;
00126 #endif
00127
00128
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
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
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
00204
00205
00206
00207
00208
00209
00210
00211
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
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
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
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
00264
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
00283
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
00302
00303
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
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
00361
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
00376
00377
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
00443
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
02453
02454
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
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
03142
03143
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
03193
03194
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
03250
03251
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
03288
03289
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
03339
03340
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
03759 jmethodID setLengthID;
03760 jclass sbufClass = ( *jenv )->GetObjectClass( jenv, jarg1 );
03761
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
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
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
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
04074 jmethodID setLengthID;
04075 jclass sbufClass = ( *jenv )->GetObjectClass( jenv, jarg1 );
04076
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
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
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
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
04584 jmethodID setLengthID;
04585 jclass sbufClass = ( *jenv )->GetObjectClass( jenv, jarg1 );
04586
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
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
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
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
04923
04924
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
05133
05134
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
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
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
05480
05481
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
05518
05519
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
06118
06119
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
06347
06348
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
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
06405
06406
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
06420
06421
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
06443
06444
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
06481
06482
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
06521
06522
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
06575
06576
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
07059
07060
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
07151
07152
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
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
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
07958 if ( labelClass != 0 )
07959 {
07960 ( *jenv )->DeleteGlobalRef( jenv, labelClass );
07961 labelClass = 0;
07962 }
07963
07964
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
08160 if ( ctClass != 0 )
08161 {
08162 ( *jenv )->DeleteGlobalRef( jenv, ctClass );
08163 ctClass = 0;
08164 }
08165
08166
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
08201
08202
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
08246
08247
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
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
08466
08467
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
08582
08583
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
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
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