PLplot: plplotjavacJAVA_wrap.c Source File

PLplot 5.10.0

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
plplotjavacJAVA_wrap.c
Go to the documentation of this file.
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 2.0.7
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGJAVA
12
13 /* -----------------------------------------------------------------------------
14 * This section contains generic SWIG labels for method/variable
15 * declarations/attributes, and other compiler dependent labels.
16 * ----------------------------------------------------------------------------- */
17
18 /* template workaround for compilers that cannot correctly implement the C++ standard */
19 #ifndef SWIGTEMPLATEDISAMBIGUATOR
20 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
21 # define SWIGTEMPLATEDISAMBIGUATOR template
22 # elif defined(__HP_aCC)
23 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
24 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
25 # define SWIGTEMPLATEDISAMBIGUATOR template
26 # else
27 # define SWIGTEMPLATEDISAMBIGUATOR
28 # endif
29 #endif
30
31 /* inline attribute */
32 #ifndef SWIGINLINE
33 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
34 # define SWIGINLINE inline
35 # else
36 # define SWIGINLINE
37 # endif
38 #endif
39
40 /* attribute recognised by some compilers to avoid 'unused' warnings */
41 #ifndef SWIGUNUSED
42 # if defined(__GNUC__)
43 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
44 # define SWIGUNUSED __attribute__ ((__unused__))
45 # else
46 # define SWIGUNUSED
47 # endif
48 # elif defined(__ICC)
49 # define SWIGUNUSED __attribute__ ((__unused__))
50 # else
51 # define SWIGUNUSED
52 # endif
53 #endif
54
55 #ifndef SWIG_MSC_UNSUPPRESS_4505
56 # if defined(_MSC_VER)
57 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
58 # endif
59 #endif
60
61 #ifndef SWIGUNUSEDPARM
62 # ifdef __cplusplus
63 # define SWIGUNUSEDPARM(p)
64 # else
65 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
66 # endif
67 #endif
68
69 /* internal SWIG method */
70 #ifndef SWIGINTERN
71 # define SWIGINTERN static SWIGUNUSED
72 #endif
73
74 /* internal inline SWIG method */
75 #ifndef SWIGINTERNINLINE
76 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
77 #endif
78
79 /* exporting methods */
80 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
81 # ifndef GCC_HASCLASSVISIBILITY
82 # define GCC_HASCLASSVISIBILITY
83 # endif
84 #endif
85
86 #ifndef SWIGEXPORT
87 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
88 # if defined(STATIC_LINKED)
89 # define SWIGEXPORT
90 # else
91 # define SWIGEXPORT __declspec(dllexport)
92 # endif
93 # else
94 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
95 # define SWIGEXPORT __attribute__ ((visibility("default")))
96 # else
97 # define SWIGEXPORT
98 # endif
99 # endif
100 #endif
101
102 /* calling conventions for Windows */
103 #ifndef SWIGSTDCALL
104 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
105 # define SWIGSTDCALL __stdcall
106 # else
107 # define SWIGSTDCALL
108 # endif
109 #endif
110
111 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
112 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
113 # define _CRT_SECURE_NO_DEPRECATE
114 #endif
115
116 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
117 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
118 # define _SCL_SECURE_NO_DEPRECATE
119 #endif
120
121
122
123 /* Fix for jlong on some versions of gcc on Windows */
124 #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
125 typedef long long __int64;
126 #endif
127
128 /* Fix for jlong on 64-bit x86 Solaris */
129 #if defined(__x86_64)
130 # ifdef _LP64
131 # undef _LP64
132 # endif
133 #endif
134
135 #include <jni.h>
136 #include <stdlib.h>
137 #include <string.h>
138
139
140 /* Support for throwing Java exceptions */
141 typedef enum {
142 SWIG_JavaOutOfMemoryError = 1,
143 SWIG_JavaIOException,
144 SWIG_JavaRuntimeException,
145 SWIG_JavaIndexOutOfBoundsException,
146 SWIG_JavaArithmeticException,
147 SWIG_JavaIllegalArgumentException,
148 SWIG_JavaNullPointerException,
149 SWIG_JavaDirectorPureVirtual,
150 SWIG_JavaUnknownError
151 } SWIG_JavaExceptionCodes;
152
153 typedef struct {
154 SWIG_JavaExceptionCodes code;
155 const char *java_exception;
156 } SWIG_JavaExceptions_t;
157
158
159 static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) {
160 jclass excep;
161 static const SWIG_JavaExceptions_t java_exceptions[] = {
162 { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" },
163 { SWIG_JavaIOException, "java/io/IOException" },
164 { SWIG_JavaRuntimeException, "java/lang/RuntimeException" },
165 { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" },
166 { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" },
167 { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" },
168 { SWIG_JavaNullPointerException, "java/lang/NullPointerException" },
169 { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" },
170 { SWIG_JavaUnknownError, "java/lang/UnknownError" },
171 { (SWIG_JavaExceptionCodes)0, "java/lang/UnknownError" }
172 };
173 const SWIG_JavaExceptions_t *except_ptr = java_exceptions;
174
175 while (except_ptr->code != code && except_ptr->code)
176 except_ptr++;
177
178 (*jenv)->ExceptionClear(jenv);
179 excep = (*jenv)->FindClass(jenv, except_ptr->java_exception);
180 if (excep)
181 (*jenv)->ThrowNew(jenv, excep, msg);
182 }
183
184
185 /* Contract support */
186
187 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } else
188
189
190 #include "plplotP.h"
191
192
193 static JavaVM *cached_jvm = NULL;
194
195 SWIGEXPORT JNIEXPORT jint JNICALL JNI_OnLoad( JavaVM *jvm, void * PL_UNUSED( reserved ) )
196 {
197 cached_jvm = jvm;
198 return JNI_VERSION_1_2;
199 }
200
201
202 //--------------------------------------------------------------------------
203 // Array allocation & copy helper routines. Note because of swig limitations
204 // it is necessary to release the java array memory right after calling these
205 // routines. Thus it is necessary to allocate and copy the arrays even if
206 // the java and plplot arrays are of the same type. Note, because of this
207 // change to Geoffrey's original versions, caller must always free memory
208 // afterwards. Thus, the must_free_buffers logic is gone as well.
209 //--------------------------------------------------------------------------
210
211 // 1d array of jbooleans
212
213 static void
214 setup_array_1d_b( PLBOOL **pa, jboolean *adat, int n )
215 {
216 int i;
217 *pa = (PLBOOL *) malloc( (size_t) n * sizeof ( PLBOOL ) );
218 for ( i = 0; i < n; i++ )
219 {
220 ( *pa )[i] = adat[i] ? 1 : 0;
221 }
222 }
223
224 // 1d array of jints
225
226 static void
227 setup_array_1d_i( PLINT **pa, jint *adat, int n )
228 {
229 int i;
230 *pa = (PLINT *) malloc( (size_t) n * sizeof ( PLINT ) );
231 for ( i = 0; i < n; i++ )
232 {
233 ( *pa )[i] = adat[i];
234 }
235 }
236
237 // 1d array of jfloats
238
239 static void
240 setup_array_1d_f( PLFLT **pa, jfloat *adat, int n )
241 {
242 int i;
243 *pa = (PLFLT *) malloc( (size_t) n * sizeof ( PLFLT ) );
244 for ( i = 0; i < n; i++ )
245 {
246 ( *pa )[i] = adat[i];
247 }
248 }
249
250 // 1d array of jdoubles
251
252 static void
253 setup_array_1d_d( PLFLT **pa, jdouble *adat, int n )
254 {
255 int i;
256 *pa = (PLFLT *) malloc( (size_t) n * sizeof ( PLFLT ) );
257 for ( i = 0; i < n; i++ )
258 {
259 ( *pa )[i] = adat[i];
260 }
261 }
262
263 // 2d array of floats
264 // Here caller must free(a[0]) and free(a) (in that order) afterward
265
266 static void
267 setup_array_2d_f( PLFLT ***pa, jfloat **adat, int nx, int ny )
268 {
269 int i, j;
270
271 *pa = (PLFLT **) malloc( (size_t) nx * sizeof ( PLFLT * ) );
272 ( *pa )[0] = (PLFLT *) malloc( (size_t) ( nx * ny ) * sizeof ( PLFLT ) );
273
274 for ( i = 0; i < nx; i++ )
275 {
276 ( *pa )[i] = ( *pa )[0] + i * ny;
277 for ( j = 0; j < ny; j++ )
278 ( *pa )[i][j] = adat[i][j];
279 }
280 }
281
282 // 2d array of doubles
283 // Here caller must free(a[0]) and free(a) (in that order) afterward
284
285 static void
286 setup_array_2d_d( PLFLT ***pa, jdouble **adat, int nx, int ny )
287 {
288 int i, j;
289
290 *pa = (PLFLT **) malloc( (size_t) nx * sizeof ( PLFLT * ) );
291 ( *pa )[0] = (PLFLT *) malloc( (size_t) ( nx * ny ) * sizeof ( PLFLT ) );
292
293 for ( i = 0; i < nx; i++ )
294 {
295 ( *pa )[i] = ( *pa )[0] + i * ny;
296 for ( j = 0; j < ny; j++ )
297 ( *pa )[i][j] = adat[i][j];
298 }
299 }
300
301 // Setup java arrays (for callback functions)
302
303 // Create a jdoubleArray and fill it from the C PLFLT array dat
304 static jdoubleArray
305 setup_java_array_1d_PLFLT( JNIEnv *jenv, PLFLT *dat, PLINT n )
306 {
307 double *x;
308 jdoubleArray jadat;
309 #ifdef PL_DOUBLE
310 x = (double *) dat;
311 #else
312 x = (double *) malloc( (size_t) n * sizeof ( double ) );
313 for ( i = 0; i < n; i++ )
314 {
315 x[i] = (double) dat[i];
316 }
317 #endif
318 jadat = ( *jenv )->NewDoubleArray( jenv, n );
319 ( *jenv )->SetDoubleArrayRegion( jenv, jadat, 0, n, x );
320 #ifndef PL_DOUBLE
321 free( x );
322 #endif
323 return jadat;
324 }
325
326 // Copy back data from jdoubleArray to C PLFLT array then release java array
327 static void
328 release_java_array_1d_PLFLT( JNIEnv *jenv, jdoubleArray jadat, PLFLT *dat, PLINT n )
329 {
330 PLINT i;
331 jdouble *jdata = ( *jenv )->GetDoubleArrayElements( jenv, jadat, 0 );
332 for ( i = 0; i < n; i++ )
333 {
334 dat[i] = (PLFLT) jdata[i];
335 }
336 ( *jenv )->ReleaseDoubleArrayElements( jenv, jadat, jdata, 0 );
337 }
338
339
340
341 static PLINT Alen = 0;
342 static PLINT Xlen = 0, Ylen = 0;
343 static PLFLT **xg;
344 static PLFLT **yg;
345 static PLcGrid2 *cgrid;
346
347
348 typedef PLINT ( *defined_func )( PLFLT, PLFLT );
349 typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
350 typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
351 typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
352 typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
353 typedef PLFLT ( *f2eval_func )( PLINT, PLINT, PLPointer );
354 typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
355
356
357 jobject mapformClass;
358 jmethodID mapformID;
359 JNIEnv *cbenvMapform;
360
361 void mapform_java( PLINT n, PLFLT *x, PLFLT *y );
362
363 // C mapform callback function which calls the java
364 // mapform function in a PLCallbackMapform object.
365 void mapform_java( PLINT n, PLFLT *x, PLFLT *y )
366 {
367 jdoubleArray jx = setup_java_array_1d_PLFLT( cbenvMapform, x, n );
368 jdoubleArray jy = setup_java_array_1d_PLFLT( cbenvMapform, y, n );
369 ( *cbenvMapform )->CallVoidMethod( cbenvMapform, mapformClass, mapformID, jx, jy );
370 release_java_array_1d_PLFLT( cbenvMapform, jx, x, n );
371 release_java_array_1d_PLFLT( cbenvMapform, jy, y, n );
372 }
373
374
375 jobject labelClass = 0;
376 jobject labelClassRef = 0;
377
378 void label_java( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data );
379
380 // C label plotting callback function which calls the java
381 // label function in a PLCallbackLabel labelClassobelID
382 // bject.
383 void label_java( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer PL_UNUSED( data ) )
384 {
385 jstring javaString;
386 const char *nativeString;
387 jint jaxis;
388 jdouble jvalue;
389 JNIEnv *cbenv;
390 jmethodID labelID = 0;
391 jclass cls;
392
393 jaxis = (jint) axis;
394 jvalue = (jdouble) value;
395
396 if ( ( string == NULL ) || ( len == 0 ) )
397 {
398 return;
399 }
400
401 string[0] = '\0';
402
403 if ( cached_jvm == NULL )
404 {
405 fprintf( stderr, "Error! NULL jvm\n" );
406 return;
407 }
408 ( *cached_jvm )->GetEnv( cached_jvm, (void **) &cbenv, JNI_VERSION_1_2 );
409 if ( cbenv == NULL )
410 {
411 fprintf( stderr, "Thread not attached\n" );
412 if ( ( *cached_jvm )->AttachCurrentThread( cached_jvm, (void **) &cbenv, NULL ) != 0 )
413 {
414 fprintf( stderr, "Error attaching to JVM\n" );
415 return;
416 }
417 }
418 if ( labelClass == 0 )
419 {
420 fprintf( stderr, "Error - callback undefined\n" );
421 return;
422 }
423 cls = ( *cbenv )->GetObjectClass( cbenv, labelClass );
424 if ( cls == 0 )
425 {
426 fprintf( stderr, "Error getting callback class\n" );
427 return;
428 }
429 labelID = ( *cbenv )->GetMethodID( cbenv, cls, "label", "(ID)Ljava/lang/String;" );
430 if ( labelID != 0 )
431 {
432 javaString = (jstring) ( *cbenv )->CallObjectMethod( cbenv, labelClass, labelID, jaxis, jvalue );
433 nativeString = ( *cbenv )->GetStringUTFChars( cbenv, javaString, 0 );
434 strncpy( string, nativeString, (size_t) len );
435 ( *cbenv )->ReleaseStringUTFChars( cbenv, javaString, nativeString );
436 }
437 else
438 {
439 fprintf( stderr, "Java callback not found\n" );
440 string[0] = '\0';
441 }
442 }
443
444
445 jobject ctClass = 0;
446 jobject ctClassRef = 0;
447
448 void ct_java( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data );
449
450 // C coordinate transform callback function which calls the java
451 // coordinate transform function in a PLCallbackCoordTrans object.
452 void ct_java( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
453 {
454 jdouble jx, jy;
455 jdoubleArray jxt, jyt;
456 jdouble *xtval;
457 jdouble *ytval;
458 jobject jdata;
459 JNIEnv *cbenv;
460 jmethodID ctID = 0;
461 jclass cls;
462
463 jx = (jdouble) x;
464 jy = (jdouble) y;
465 jdata = (jobject) data;
466
467 if ( cached_jvm == NULL )
468 {
469 fprintf( stderr, "Error! NULL jvm\n" );
470 return;
471 }
472 ( *cached_jvm )->GetEnv( cached_jvm, (void **) &cbenv, JNI_VERSION_1_2 );
473 if ( cbenv == NULL )
474 {
475 fprintf( stderr, "Thread not attached\n" );
476 if ( ( *cached_jvm )->AttachCurrentThread( cached_jvm, (void **) &cbenv, NULL ) != 0 )
477 {
478 fprintf( stderr, "Error attaching to JVM\n" );
479 return;
480 }
481 }
482 jxt = ( *cbenv )->NewDoubleArray( cbenv, 1 );
483 jyt = ( *cbenv )->NewDoubleArray( cbenv, 1 );
484 if ( ctClass == 0 )
485 {
486 fprintf( stderr, "Error - callback undefined\n" );
487 return;
488 }
489 cls = ( *cbenv )->GetObjectClass( cbenv, ctClass );
490 if ( cls == 0 )
491 {
492 fprintf( stderr, "Error getting callback class\n" );
493 return;
494 }
495 ctID = ( *cbenv )->GetMethodID( cbenv, cls, "coordTransform", "(DD[D[DLjava/lang/Object;)V" );
496 if ( ctID != 0 )
497 {
498 ( *cbenv )->CallVoidMethod( cbenv, ctClass, ctID, jx, jy, jxt, jyt, jdata );
499 xtval = ( *cbenv )->GetDoubleArrayElements( cbenv, jxt, JNI_FALSE );
500 ytval = ( *cbenv )->GetDoubleArrayElements( cbenv, jyt, JNI_FALSE );
501 *xt = (PLFLT) xtval[0];
502 *yt = (PLFLT) ytval[0];
503 }
504 else
505 {
506 fprintf( stderr, "Java callback not found\n" );
507 }
508 }
509
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 SWIGEXPORT jstring JNICALL Java_plplot_core_plplotjavacJNI_jPLFLTArray_1get(JNIEnv *jenv, jclass jcls) {
516 jstring jresult = 0 ;
517 char *result = 0 ;
518
519 (void)jenv;
520 (void)jcls;
521 result = (char *)("jdoubleArray");
522 if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result);
523 return jresult;
524 }
525
526
527 SWIGEXPORT jstring JNICALL Java_plplot_core_plplotjavacJNI_jPLFLTbracket_1get(JNIEnv *jenv, jclass jcls) {
528 jstring jresult = 0 ;
529 char *result = 0 ;
530
531 (void)jenv;
532 (void)jcls;
533 result = (char *)("double[]");
534 if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result);
535 return jresult;
536 }
537
538
539 SWIGEXPORT jstring JNICALL Java_plplot_core_plplotjavacJNI_jPLFLTbracket2_1get(JNIEnv *jenv, jclass jcls) {
540 jstring jresult = 0 ;
541 char *result = 0 ;
542
543 (void)jenv;
544 (void)jcls;
545 result = (char *)("double[][]");
546 if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result);
547 return jresult;
548 }
549
550
551 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1SET_1RGB_1get(JNIEnv *jenv, jclass jcls) {
552 jint jresult = 0 ;
553 int result;
554
555 (void)jenv;
556 (void)jcls;
557 result = (int)(1);
558 jresult = (jint)result;
559 return jresult;
560 }
561
562
563 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1ALLOC_1NCOL_1get(JNIEnv *jenv, jclass jcls) {
564 jint jresult = 0 ;
565 int result;
566
567 (void)jenv;
568 (void)jcls;
569 result = (int)(2);
570 jresult = (jint)result;
571 return jresult;
572 }
573
574
575 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1SET_1LPB_1get(JNIEnv *jenv, jclass jcls) {
576 jint jresult = 0 ;
577 int result;
578
579 (void)jenv;
580 (void)jcls;
581 result = (int)(3);
582 jresult = (jint)result;
583 return jresult;
584 }
585
586
587 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1EXPOSE_1get(JNIEnv *jenv, jclass jcls) {
588 jint jresult = 0 ;
589 int result;
590
591 (void)jenv;
592 (void)jcls;
593 result = (int)(4);
594 jresult = (jint)result;
595 return jresult;
596 }
597
598
599 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1RESIZE_1get(JNIEnv *jenv, jclass jcls) {
600 jint jresult = 0 ;
601 int result;
602
603 (void)jenv;
604 (void)jcls;
605 result = (int)(5);
606 jresult = (jint)result;
607 return jresult;
608 }
609
610
611 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1REDRAW_1get(JNIEnv *jenv, jclass jcls) {
612 jint jresult = 0 ;
613 int result;
614
615 (void)jenv;
616 (void)jcls;
617 result = (int)(6);
618 jresult = (jint)result;
619 return jresult;
620 }
621
622
623 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1TEXT_1get(JNIEnv *jenv, jclass jcls) {
624 jint jresult = 0 ;
625 int result;
626
627 (void)jenv;
628 (void)jcls;
629 result = (int)(7);
630 jresult = (jint)result;
631 return jresult;
632 }
633
634
635 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1GRAPH_1get(JNIEnv *jenv, jclass jcls) {
636 jint jresult = 0 ;
637 int result;
638
639 (void)jenv;
640 (void)jcls;
641 result = (int)(8);
642 jresult = (jint)result;
643 return jresult;
644 }
645
646
647 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1FILL_1get(JNIEnv *jenv, jclass jcls) {
648 jint jresult = 0 ;
649 int result;
650
651 (void)jenv;
652 (void)jcls;
653 result = (int)(9);
654 jresult = (jint)result;
655 return jresult;
656 }
657
658
659 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1DI_1get(JNIEnv *jenv, jclass jcls) {
660 jint jresult = 0 ;
661 int result;
662
663 (void)jenv;
664 (void)jcls;
665 result = (int)(10);
666 jresult = (jint)result;
667 return jresult;
668 }
669
670
671 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1FLUSH_1get(JNIEnv *jenv, jclass jcls) {
672 jint jresult = 0 ;
673 int result;
674
675 (void)jenv;
676 (void)jcls;
677 result = (int)(11);
678 jresult = (jint)result;
679 return jresult;
680 }
681
682
683 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1EH_1get(JNIEnv *jenv, jclass jcls) {
684 jint jresult = 0 ;
685 int result;
686
687 (void)jenv;
688 (void)jcls;
689 result = (int)(12);
690 jresult = (jint)result;
691 return jresult;
692 }
693
694
695 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1GETC_1get(JNIEnv *jenv, jclass jcls) {
696 jint jresult = 0 ;
697 int result;
698
699 (void)jenv;
700 (void)jcls;
701 result = (int)(13);
702 jresult = (jint)result;
703 return jresult;
704 }
705
706
707 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1SWIN_1get(JNIEnv *jenv, jclass jcls) {
708 jint jresult = 0 ;
709 int result;
710
711 (void)jenv;
712 (void)jcls;
713 result = (int)(14);
714 jresult = (jint)result;
715 return jresult;
716 }
717
718
719 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1DOUBLEBUFFERING_1get(JNIEnv *jenv, jclass jcls) {
720 jint jresult = 0 ;
721 int result;
722
723 (void)jenv;
724 (void)jcls;
725 result = (int)(15);
726 jresult = (jint)result;
727 return jresult;
728 }
729
730
731 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1XORMOD_1get(JNIEnv *jenv, jclass jcls) {
732 jint jresult = 0 ;
733 int result;
734
735 (void)jenv;
736 (void)jcls;
737 result = (int)(16);
738 jresult = (jint)result;
739 return jresult;
740 }
741
742
743 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1SET_1COMPRESSION_1get(JNIEnv *jenv, jclass jcls) {
744 jint jresult = 0 ;
745 int result;
746
747 (void)jenv;
748 (void)jcls;
749 result = (int)(17);
750 jresult = (jint)result;
751 return jresult;
752 }
753
754
755 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1CLEAR_1get(JNIEnv *jenv, jclass jcls) {
756 jint jresult = 0 ;
757 int result;
758
759 (void)jenv;
760 (void)jcls;
761 result = (int)(18);
762 jresult = (jint)result;
763 return jresult;
764 }
765
766
767 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1DASH_1get(JNIEnv *jenv, jclass jcls) {
768 jint jresult = 0 ;
769 int result;
770
771 (void)jenv;
772 (void)jcls;
773 result = (int)(19);
774 jresult = (jint)result;
775 return jresult;
776 }
777
778
779 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1HAS_1TEXT_1get(JNIEnv *jenv, jclass jcls) {
780 jint jresult = 0 ;
781 int result;
782
783 (void)jenv;
784 (void)jcls;
785 result = (int)(20);
786 jresult = (jint)result;
787 return jresult;
788 }
789
790
791 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1IMAGE_1get(JNIEnv *jenv, jclass jcls) {
792 jint jresult = 0 ;
793 int result;
794
795 (void)jenv;
796 (void)jcls;
797 result = (int)(21);
798 jresult = (jint)result;
799 return jresult;
800 }
801
802
803 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1IMAGEOPS_1get(JNIEnv *jenv, jclass jcls) {
804 jint jresult = 0 ;
805 int result;
806
807 (void)jenv;
808 (void)jcls;
809 result = (int)(22);
810 jresult = (jint)result;
811 return jresult;
812 }
813
814
815 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1PL2DEVCOL_1get(JNIEnv *jenv, jclass jcls) {
816 jint jresult = 0 ;
817 int result;
818
819 (void)jenv;
820 (void)jcls;
821 result = (int)(23);
822 jresult = (jint)result;
823 return jresult;
824 }
825
826
827 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1DEV2PLCOL_1get(JNIEnv *jenv, jclass jcls) {
828 jint jresult = 0 ;
829 int result;
830
831 (void)jenv;
832 (void)jcls;
833 result = (int)(24);
834 jresult = (jint)result;
835 return jresult;
836 }
837
838
839 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1SETBGFG_1get(JNIEnv *jenv, jclass jcls) {
840 jint jresult = 0 ;
841 int result;
842
843 (void)jenv;
844 (void)jcls;
845 result = (int)(25);
846 jresult = (jint)result;
847 return jresult;
848 }
849
850
851 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1DEVINIT_1get(JNIEnv *jenv, jclass jcls) {
852 jint jresult = 0 ;
853 int result;
854
855 (void)jenv;
856 (void)jcls;
857 result = (int)(26);
858 jresult = (jint)result;
859 return jresult;
860 }
861
862
863 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1GETBACKEND_1get(JNIEnv *jenv, jclass jcls) {
864 jint jresult = 0 ;
865 int result;
866
867 (void)jenv;
868 (void)jcls;
869 result = (int)(27);
870 jresult = (jint)result;
871 return jresult;
872 }
873
874
875 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1BEGIN_1TEXT_1get(JNIEnv *jenv, jclass jcls) {
876 jint jresult = 0 ;
877 int result;
878
879 (void)jenv;
880 (void)jcls;
881 result = (int)(28);
882 jresult = (jint)result;
883 return jresult;
884 }
885
886
887 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1TEXT_1CHAR_1get(JNIEnv *jenv, jclass jcls) {
888 jint jresult = 0 ;
889 int result;
890
891 (void)jenv;
892 (void)jcls;
893 result = (int)(29);
894 jresult = (jint)result;
895 return jresult;
896 }
897
898
899 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1CONTROL_1CHAR_1get(JNIEnv *jenv, jclass jcls) {
900 jint jresult = 0 ;
901 int result;
902
903 (void)jenv;
904 (void)jcls;
905 result = (int)(30);
906 jresult = (jint)result;
907 return jresult;
908 }
909
910
911 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1END_1TEXT_1get(JNIEnv *jenv, jclass jcls) {
912 jint jresult = 0 ;
913 int result;
914
915 (void)jenv;
916 (void)jcls;
917 result = (int)(31);
918 jresult = (jint)result;
919 return jresult;
920 }
921
922
923 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1START_1RASTERIZE_1get(JNIEnv *jenv, jclass jcls) {
924 jint jresult = 0 ;
925 int result;
926
927 (void)jenv;
928 (void)jcls;
929 result = (int)(32);
930 jresult = (jint)result;
931 return jresult;
932 }
933
934
935 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1END_1RASTERIZE_1get(JNIEnv *jenv, jclass jcls) {
936 jint jresult = 0 ;
937 int result;
938
939 (void)jenv;
940 (void)jcls;
941 result = (int)(33);
942 jresult = (jint)result;
943 return jresult;
944 }
945
946
947 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1ARC_1get(JNIEnv *jenv, jclass jcls) {
948 jint jresult = 0 ;
949 int result;
950
951 (void)jenv;
952 (void)jcls;
953 result = (int)(34);
954 jresult = (jint)result;
955 return jresult;
956 }
957
958
959 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1GRADIENT_1get(JNIEnv *jenv, jclass jcls) {
960 jint jresult = 0 ;
961 int result;
962
963 (void)jenv;
964 (void)jcls;
965 result = (int)(35);
966 jresult = (jint)result;
967 return jresult;
968 }
969
970
971 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1MODESET_1get(JNIEnv *jenv, jclass jcls) {
972 jint jresult = 0 ;
973 int result;
974
975 (void)jenv;
976 (void)jcls;
977 result = (int)(36);
978 jresult = (jint)result;
979 return jresult;
980 }
981
982
983 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1MODEGET_1get(JNIEnv *jenv, jclass jcls) {
984 jint jresult = 0 ;
985 int result;
986
987 (void)jenv;
988 (void)jcls;
989 result = (int)(37);
990 jresult = (jint)result;
991 return jresult;
992 }
993
994
995 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLTEXT_1FONTCHANGE_1get(JNIEnv *jenv, jclass jcls) {
996 jint jresult = 0 ;
997 int result;
998
999 (void)jenv;
1000 (void)jcls;
1001 result = (int)(0);
1002 jresult = (jint)result;
1003 return jresult;
1004 }
1005
1006
1007 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLTEXT_1SUPERSCRIPT_1get(JNIEnv *jenv, jclass jcls) {
1008 jint jresult = 0 ;
1009 int result;
1010
1011 (void)jenv;
1012 (void)jcls;
1013 result = (int)(1);
1014 jresult = (jint)result;
1015 return jresult;
1016 }
1017
1018
1019 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLTEXT_1SUBSCRIPT_1get(JNIEnv *jenv, jclass jcls) {
1020 jint jresult = 0 ;
1021 int result;
1022
1023 (void)jenv;
1024 (void)jcls;
1025 result = (int)(2);
1026 jresult = (jint)result;
1027 return jresult;
1028 }
1029
1030
1031 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLTEXT_1BACKCHAR_1get(JNIEnv *jenv, jclass jcls) {
1032 jint jresult = 0 ;
1033 int result;
1034
1035 (void)jenv;
1036 (void)jcls;
1037 result = (int)(3);
1038 jresult = (jint)result;
1039 return jresult;
1040 }
1041
1042
1043 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLTEXT_1OVERLINE_1get(JNIEnv *jenv, jclass jcls) {
1044 jint jresult = 0 ;
1045 int result;
1046
1047 (void)jenv;
1048 (void)jcls;
1049 result = (int)(4);
1050 jresult = (jint)result;
1051 return jresult;
1052 }
1053
1054
1055 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLTEXT_1UNDERLINE_1get(JNIEnv *jenv, jclass jcls) {
1056 jint jresult = 0 ;
1057 int result;
1058
1059 (void)jenv;
1060 (void)jcls;
1061 result = (int)(5);
1062 jresult = (jint)result;
1063 return jresult;
1064 }
1065
1066
1067 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_ZEROW2B_1get(JNIEnv *jenv, jclass jcls) {
1068 jint jresult = 0 ;
1069 int result;
1070
1071 (void)jenv;
1072 (void)jcls;
1073 result = (int)(1);
1074 jresult = (jint)result;
1075 return jresult;
1076 }
1077
1078
1079 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_ZEROW2D_1get(JNIEnv *jenv, jclass jcls) {
1080 jint jresult = 0 ;
1081 int result;
1082
1083 (void)jenv;
1084 (void)jcls;
1085 result = (int)(2);
1086 jresult = (jint)result;
1087 return jresult;
1088 }
1089
1090
1091 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_ONEW2B_1get(JNIEnv *jenv, jclass jcls) {
1092 jint jresult = 0 ;
1093 int result;
1094
1095 (void)jenv;
1096 (void)jcls;
1097 result = (int)(3);
1098 jresult = (jint)result;
1099 return jresult;
1100 }
1101
1102
1103 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_ONEW2D_1get(JNIEnv *jenv, jclass jcls) {
1104 jint jresult = 0 ;
1105 int result;
1106
1107 (void)jenv;
1108 (void)jcls;
1109 result = (int)(4);
1110 jresult = (jint)result;
1111 return jresult;
1112 }
1113
1114
1115 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLSWIN_1DEVICE_1get(JNIEnv *jenv, jclass jcls) {
1116 jint jresult = 0 ;
1117 int result;
1118
1119 (void)jenv;
1120 (void)jcls;
1121 result = (int)(1);
1122 jresult = (jint)result;
1123 return jresult;
1124 }
1125
1126
1127 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLSWIN_1WORLD_1get(JNIEnv *jenv, jclass jcls) {
1128 jint jresult = 0 ;
1129 int result;
1130
1131 (void)jenv;
1132 (void)jcls;
1133 result = (int)(2);
1134 jresult = (jint)result;
1135 return jresult;
1136 }
1137
1138
1139 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1X_1AXIS_1get(JNIEnv *jenv, jclass jcls) {
1140 jint jresult = 0 ;
1141 int result;
1142
1143 (void)jenv;
1144 (void)jcls;
1145 result = (int)(1);
1146 jresult = (jint)result;
1147 return jresult;
1148 }
1149
1150
1151 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1Y_1AXIS_1get(JNIEnv *jenv, jclass jcls) {
1152 jint jresult = 0 ;
1153 int result;
1154
1155 (void)jenv;
1156 (void)jcls;
1157 result = (int)(2);
1158 jresult = (jint)result;
1159 return jresult;
1160 }
1161
1162
1163 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1Z_1AXIS_1get(JNIEnv *jenv, jclass jcls) {
1164 jint jresult = 0 ;
1165 int result;
1166
1167 (void)jenv;
1168 (void)jcls;
1169 result = (int)(3);
1170 jresult = (jint)result;
1171 return jresult;
1172 }
1173
1174
1175 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1OPT_1ENABLED_1get(JNIEnv *jenv, jclass jcls) {
1176 jint jresult = 0 ;
1177 int result;
1178
1179 (void)jenv;
1180 (void)jcls;
1181 result = (int)(0x0001);
1182 jresult = (jint)result;
1183 return jresult;
1184 }
1185
1186
1187 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1OPT_1ARG_1get(JNIEnv *jenv, jclass jcls) {
1188 jint jresult = 0 ;
1189 int result;
1190
1191 (void)jenv;
1192 (void)jcls;
1193 result = (int)(0x0002);
1194 jresult = (jint)result;
1195 return jresult;
1196 }
1197
1198
1199 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1OPT_1NODELETE_1get(JNIEnv *jenv, jclass jcls) {
1200 jint jresult = 0 ;
1201 int result;
1202
1203 (void)jenv;
1204 (void)jcls;
1205 result = (int)(0x0004);
1206 jresult = (jint)result;
1207 return jresult;
1208 }
1209
1210
1211 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1OPT_1INVISIBLE_1get(JNIEnv *jenv, jclass jcls) {
1212 jint jresult = 0 ;
1213 int result;
1214
1215 (void)jenv;
1216 (void)jcls;
1217 result = (int)(0x0008);
1218 jresult = (jint)result;
1219 return jresult;
1220 }
1221
1222
1223 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1OPT_1DISABLED_1get(JNIEnv *jenv, jclass jcls) {
1224 jint jresult = 0 ;
1225 int result;
1226
1227 (void)jenv;
1228 (void)jcls;
1229 result = (int)(0x0010);
1230 jresult = (jint)result;
1231 return jresult;
1232 }
1233
1234
1235 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1OPT_1FUNC_1get(JNIEnv *jenv, jclass jcls) {
1236 jint jresult = 0 ;
1237 int result;
1238
1239 (void)jenv;
1240 (void)jcls;
1241 result = (int)(0x0100);
1242 jresult = (jint)result;
1243 return jresult;
1244 }
1245
1246
1247 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1OPT_1BOOL_1get(JNIEnv *jenv, jclass jcls) {
1248 jint jresult = 0 ;
1249 int result;
1250
1251 (void)jenv;
1252 (void)jcls;
1253 result = (int)(0x0200);
1254 jresult = (jint)result;
1255 return jresult;
1256 }
1257
1258
1259 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1OPT_1INT_1get(JNIEnv *jenv, jclass jcls) {
1260 jint jresult = 0 ;
1261 int result;
1262
1263 (void)jenv;
1264 (void)jcls;
1265 result = (int)(0x0400);
1266 jresult = (jint)result;
1267 return jresult;
1268 }
1269
1270
1271 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1OPT_1FLOAT_1get(JNIEnv *jenv, jclass jcls) {
1272 jint jresult = 0 ;
1273 int result;
1274
1275 (void)jenv;
1276 (void)jcls;
1277 result = (int)(0x0800);
1278 jresult = (jint)result;
1279 return jresult;
1280 }
1281
1282
1283 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1OPT_1STRING_1get(JNIEnv *jenv, jclass jcls) {
1284 jint jresult = 0 ;
1285 int result;
1286
1287 (void)jenv;
1288 (void)jcls;
1289 result = (int)(0x1000);
1290 jresult = (jint)result;
1291 return jresult;
1292 }
1293
1294
1295 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1PARSE_1PARTIAL_1get(JNIEnv *jenv, jclass jcls) {
1296 jint jresult = 0 ;
1297 int result;
1298
1299 (void)jenv;
1300 (void)jcls;
1301 result = (int)(0x0000);
1302 jresult = (jint)result;
1303 return jresult;
1304 }
1305
1306
1307 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1PARSE_1FULL_1get(JNIEnv *jenv, jclass jcls) {
1308 jint jresult = 0 ;
1309 int result;
1310
1311 (void)jenv;
1312 (void)jcls;
1313 result = (int)(0x0001);
1314 jresult = (jint)result;
1315 return jresult;
1316 }
1317
1318
1319 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1PARSE_1QUIET_1get(JNIEnv *jenv, jclass jcls) {
1320 jint jresult = 0 ;
1321 int result;
1322
1323 (void)jenv;
1324 (void)jcls;
1325 result = (int)(0x0002);
1326 jresult = (jint)result;
1327 return jresult;
1328 }
1329
1330
1331 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1PARSE_1NODELETE_1get(JNIEnv *jenv, jclass jcls) {
1332 jint jresult = 0 ;
1333 int result;
1334
1335 (void)jenv;
1336 (void)jcls;
1337 result = (int)(0x0004);
1338 jresult = (jint)result;
1339 return jresult;
1340 }
1341
1342
1343 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1PARSE_1SHOWALL_1get(JNIEnv *jenv, jclass jcls) {
1344 jint jresult = 0 ;
1345 int result;
1346
1347 (void)jenv;
1348 (void)jcls;
1349 result = (int)(0x0008);
1350 jresult = (jint)result;
1351 return jresult;
1352 }
1353
1354
1355 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1PARSE_1OVERRIDE_1get(JNIEnv *jenv, jclass jcls) {
1356 jint jresult = 0 ;
1357 int result;
1358
1359 (void)jenv;
1360 (void)jcls;
1361 result = (int)(0x0010);
1362 jresult = (jint)result;
1363 return jresult;
1364 }
1365
1366
1367 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1PARSE_1NOPROGRAM_1get(JNIEnv *jenv, jclass jcls) {
1368 jint jresult = 0 ;
1369 int result;
1370
1371 (void)jenv;
1372 (void)jcls;
1373 result = (int)(0x0020);
1374 jresult = (jint)result;
1375 return jresult;
1376 }
1377
1378
1379 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1PARSE_1NODASH_1get(JNIEnv *jenv, jclass jcls) {
1380 jint jresult = 0 ;
1381 int result;
1382
1383 (void)jenv;
1384 (void)jcls;
1385 result = (int)(0x0040);
1386 jresult = (jint)result;
1387 return jresult;
1388 }
1389
1390
1391 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1PARSE_1SKIP_1get(JNIEnv *jenv, jclass jcls) {
1392 jint jresult = 0 ;
1393 int result;
1394
1395 (void)jenv;
1396 (void)jcls;
1397 result = (int)(0x0080);
1398 jresult = (jint)result;
1399 return jresult;
1400 }
1401
1402
1403 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1MARK_1get(JNIEnv *jenv, jclass jcls) {
1404 jint jresult = 0 ;
1405 int result;
1406
1407 (void)jenv;
1408 (void)jcls;
1409 result = (int)(0x80000000);
1410 jresult = (jint)result;
1411 return jresult;
1412 }
1413
1414
1415 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1IMPOSSIBLE_1get(JNIEnv *jenv, jclass jcls) {
1416 jint jresult = 0 ;
1417 int result;
1418
1419 (void)jenv;
1420 (void)jcls;
1421 result = (int)(0x00000000);
1422 jresult = (jint)result;
1423 return jresult;
1424 }
1425
1426
1427 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1HEXDIGIT_1MASK_1get(JNIEnv *jenv, jclass jcls) {
1428 jint jresult = 0 ;
1429 int result;
1430
1431 (void)jenv;
1432 (void)jcls;
1433 result = (int)(0xf);
1434 jresult = (jint)result;
1435 return jresult;
1436 }
1437
1438
1439 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1HEXPOWER_1MASK_1get(JNIEnv *jenv, jclass jcls) {
1440 jint jresult = 0 ;
1441 int result;
1442
1443 (void)jenv;
1444 (void)jcls;
1445 result = (int)(0x7);
1446 jresult = (jint)result;
1447 return jresult;
1448 }
1449
1450
1451 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1HEXPOWER_1IMPOSSIBLE_1get(JNIEnv *jenv, jclass jcls) {
1452 jint jresult = 0 ;
1453 int result;
1454
1455 (void)jenv;
1456 (void)jcls;
1457 result = (int)(0xf);
1458 jresult = (jint)result;
1459 return jresult;
1460 }
1461
1462
1463 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1FAMILY_1get(JNIEnv *jenv, jclass jcls) {
1464 jint jresult = 0 ;
1465 int result;
1466
1467 (void)jenv;
1468 (void)jcls;
1469 result = (int)(0x0);
1470 jresult = (jint)result;
1471 return jresult;
1472 }
1473
1474
1475 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1STYLE_1get(JNIEnv *jenv, jclass jcls) {
1476 jint jresult = 0 ;
1477 int result;
1478
1479 (void)jenv;
1480 (void)jcls;
1481 result = (int)(0x1);
1482 jresult = (jint)result;
1483 return jresult;
1484 }
1485
1486
1487 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1WEIGHT_1get(JNIEnv *jenv, jclass jcls) {
1488 jint jresult = 0 ;
1489 int result;
1490
1491 (void)jenv;
1492 (void)jcls;
1493 result = (int)(0x2);
1494 jresult = (jint)result;
1495 return jresult;
1496 }
1497
1498
1499 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1SANS_1get(JNIEnv *jenv, jclass jcls) {
1500 jint jresult = 0 ;
1501 int result;
1502
1503 (void)jenv;
1504 (void)jcls;
1505 result = (int)(0x0);
1506 jresult = (jint)result;
1507 return jresult;
1508 }
1509
1510
1511 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1SERIF_1get(JNIEnv *jenv, jclass jcls) {
1512 jint jresult = 0 ;
1513 int result;
1514
1515 (void)jenv;
1516 (void)jcls;
1517 result = (int)(0x1);
1518 jresult = (jint)result;
1519 return jresult;
1520 }
1521
1522
1523 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1MONO_1get(JNIEnv *jenv, jclass jcls) {
1524 jint jresult = 0 ;
1525 int result;
1526
1527 (void)jenv;
1528 (void)jcls;
1529 result = (int)(0x2);
1530 jresult = (jint)result;
1531 return jresult;
1532 }
1533
1534
1535 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1SCRIPT_1get(JNIEnv *jenv, jclass jcls) {
1536 jint jresult = 0 ;
1537 int result;
1538
1539 (void)jenv;
1540 (void)jcls;
1541 result = (int)(0x3);
1542 jresult = (jint)result;
1543 return jresult;
1544 }
1545
1546
1547 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1SYMBOL_1get(JNIEnv *jenv, jclass jcls) {
1548 jint jresult = 0 ;
1549 int result;
1550
1551 (void)jenv;
1552 (void)jcls;
1553 result = (int)(0x4);
1554 jresult = (jint)result;
1555 return jresult;
1556 }
1557
1558
1559 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1UPRIGHT_1get(JNIEnv *jenv, jclass jcls) {
1560 jint jresult = 0 ;
1561 int result;
1562
1563 (void)jenv;
1564 (void)jcls;
1565 result = (int)(0x0);
1566 jresult = (jint)result;
1567 return jresult;
1568 }
1569
1570
1571 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1ITALIC_1get(JNIEnv *jenv, jclass jcls) {
1572 jint jresult = 0 ;
1573 int result;
1574
1575 (void)jenv;
1576 (void)jcls;
1577 result = (int)(0x1);
1578 jresult = (jint)result;
1579 return jresult;
1580 }
1581
1582
1583 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1OBLIQUE_1get(JNIEnv *jenv, jclass jcls) {
1584 jint jresult = 0 ;
1585 int result;
1586
1587 (void)jenv;
1588 (void)jcls;
1589 result = (int)(0x2);
1590 jresult = (jint)result;
1591 return jresult;
1592 }
1593
1594
1595 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1MEDIUM_1get(JNIEnv *jenv, jclass jcls) {
1596 jint jresult = 0 ;
1597 int result;
1598
1599 (void)jenv;
1600 (void)jcls;
1601 result = (int)(0x0);
1602 jresult = (jint)result;
1603 return jresult;
1604 }
1605
1606
1607 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1FCI_1BOLD_1get(JNIEnv *jenv, jclass jcls) {
1608 jint jresult = 0 ;
1609 int result;
1610
1611 (void)jenv;
1612 (void)jcls;
1613 result = (int)(0x1);
1614 jresult = (jint)result;
1615 return jresult;
1616 }
1617
1618
1619 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1MAXKEY_1get(JNIEnv *jenv, jclass jcls) {
1620 jint jresult = 0 ;
1621 int result;
1622
1623 (void)jenv;
1624 (void)jcls;
1625 result = (int)(16);
1626 jresult = (jint)result;
1627 return jresult;
1628 }
1629
1630
1631 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1MAXWINDOWS_1get(JNIEnv *jenv, jclass jcls) {
1632 jint jresult = 0 ;
1633 int result;
1634
1635 (void)jenv;
1636 (void)jcls;
1637 result = (int)(64);
1638 jresult = (jint)result;
1639 return jresult;
1640 }
1641
1642
1643 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1NOTSET_1get(JNIEnv *jenv, jclass jcls) {
1644 jint jresult = 0 ;
1645 int result;
1646
1647 (void)jenv;
1648 (void)jcls;
1649 result = (int)((-42));
1650 jresult = (jint)result;
1651 return jresult;
1652 }
1653
1654
1655 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1DOUBLEBUFFERING_1ENABLE_1get(JNIEnv *jenv, jclass jcls) {
1656 jint jresult = 0 ;
1657 int result;
1658
1659 (void)jenv;
1660 (void)jcls;
1661 result = (int)(1);
1662 jresult = (jint)result;
1663 return jresult;
1664 }
1665
1666
1667 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1DOUBLEBUFFERING_1DISABLE_1get(JNIEnv *jenv, jclass jcls) {
1668 jint jresult = 0 ;
1669 int result;
1670
1671 (void)jenv;
1672 (void)jcls;
1673 result = (int)(2);
1674 jresult = (jint)result;
1675 return jresult;
1676 }
1677
1678
1679 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLESC_1DOUBLEBUFFERING_1QUERY_1get(JNIEnv *jenv, jclass jcls) {
1680 jint jresult = 0 ;
1681 int result;
1682
1683 (void)jenv;
1684 (void)jcls;
1685 result = (int)(3);
1686 jresult = (jint)result;
1687 return jresult;
1688 }
1689
1690
1691 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1BIN_1DEFAULT_1get(JNIEnv *jenv, jclass jcls) {
1692 jint jresult = 0 ;
1693 int result;
1694
1695 (void)jenv;
1696 (void)jcls;
1697 result = (int)(0x0);
1698 jresult = (jint)result;
1699 return jresult;
1700 }
1701
1702
1703 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1BIN_1CENTRED_1get(JNIEnv *jenv, jclass jcls) {
1704 jint jresult = 0 ;
1705 int result;
1706
1707 (void)jenv;
1708 (void)jcls;
1709 result = (int)(0x1);
1710 jresult = (jint)result;
1711 return jresult;
1712 }
1713
1714
1715 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1BIN_1NOEXPAND_1get(JNIEnv *jenv, jclass jcls) {
1716 jint jresult = 0 ;
1717 int result;
1718
1719 (void)jenv;
1720 (void)jcls;
1721 result = (int)(0x2);
1722 jresult = (jint)result;
1723 return jresult;
1724 }
1725
1726
1727 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1BIN_1NOEMPTY_1get(JNIEnv *jenv, jclass jcls) {
1728 jint jresult = 0 ;
1729 int result;
1730
1731 (void)jenv;
1732 (void)jcls;
1733 result = (int)(0x4);
1734 jresult = (jint)result;
1735 return jresult;
1736 }
1737
1738
1739 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_GRID_1CSA_1get(JNIEnv *jenv, jclass jcls) {
1740 jint jresult = 0 ;
1741 int result;
1742
1743 (void)jenv;
1744 (void)jcls;
1745 result = (int)(1);
1746 jresult = (jint)result;
1747 return jresult;
1748 }
1749
1750
1751 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_GRID_1DTLI_1get(JNIEnv *jenv, jclass jcls) {
1752 jint jresult = 0 ;
1753 int result;
1754
1755 (void)jenv;
1756 (void)jcls;
1757 result = (int)(2);
1758 jresult = (jint)result;
1759 return jresult;
1760 }
1761
1762
1763 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_GRID_1NNI_1get(JNIEnv *jenv, jclass jcls) {
1764 jint jresult = 0 ;
1765 int result;
1766
1767 (void)jenv;
1768 (void)jcls;
1769 result = (int)(3);
1770 jresult = (jint)result;
1771 return jresult;
1772 }
1773
1774
1775 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_GRID_1NNIDW_1get(JNIEnv *jenv, jclass jcls) {
1776 jint jresult = 0 ;
1777 int result;
1778
1779 (void)jenv;
1780 (void)jcls;
1781 result = (int)(4);
1782 jresult = (jint)result;
1783 return jresult;
1784 }
1785
1786
1787 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_GRID_1NNLI_1get(JNIEnv *jenv, jclass jcls) {
1788 jint jresult = 0 ;
1789 int result;
1790
1791 (void)jenv;
1792 (void)jcls;
1793 result = (int)(5);
1794 jresult = (jint)result;
1795 return jresult;
1796 }
1797
1798
1799 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_GRID_1NNAIDW_1get(JNIEnv *jenv, jclass jcls) {
1800 jint jresult = 0 ;
1801 int result;
1802
1803 (void)jenv;
1804 (void)jcls;
1805 result = (int)(6);
1806 jresult = (jint)result;
1807 return jresult;
1808 }
1809
1810
1811 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1HIST_1DEFAULT_1get(JNIEnv *jenv, jclass jcls) {
1812 jint jresult = 0 ;
1813 int result;
1814
1815 (void)jenv;
1816 (void)jcls;
1817 result = (int)(0x00);
1818 jresult = (jint)result;
1819 return jresult;
1820 }
1821
1822
1823 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1HIST_1NOSCALING_1get(JNIEnv *jenv, jclass jcls) {
1824 jint jresult = 0 ;
1825 int result;
1826
1827 (void)jenv;
1828 (void)jcls;
1829 result = (int)(0x01);
1830 jresult = (jint)result;
1831 return jresult;
1832 }
1833
1834
1835 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1HIST_1IGNORE_1OUTLIERS_1get(JNIEnv *jenv, jclass jcls) {
1836 jint jresult = 0 ;
1837 int result;
1838
1839 (void)jenv;
1840 (void)jcls;
1841 result = (int)(0x02);
1842 jresult = (jint)result;
1843 return jresult;
1844 }
1845
1846
1847 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1HIST_1NOEXPAND_1get(JNIEnv *jenv, jclass jcls) {
1848 jint jresult = 0 ;
1849 int result;
1850
1851 (void)jenv;
1852 (void)jcls;
1853 result = (int)(0x08);
1854 jresult = (jint)result;
1855 return jresult;
1856 }
1857
1858
1859 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1HIST_1NOEMPTY_1get(JNIEnv *jenv, jclass jcls) {
1860 jint jresult = 0 ;
1861 int result;
1862
1863 (void)jenv;
1864 (void)jcls;
1865 result = (int)(0x10);
1866 jresult = (jint)result;
1867 return jresult;
1868 }
1869
1870
1871 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1POSITION_1LEFT_1get(JNIEnv *jenv, jclass jcls) {
1872 jint jresult = 0 ;
1873 int result;
1874
1875 (void)jenv;
1876 (void)jcls;
1877 result = (int)(0x1);
1878 jresult = (jint)result;
1879 return jresult;
1880 }
1881
1882
1883 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1POSITION_1RIGHT_1get(JNIEnv *jenv, jclass jcls) {
1884 jint jresult = 0 ;
1885 int result;
1886
1887 (void)jenv;
1888 (void)jcls;
1889 result = (int)(0x2);
1890 jresult = (jint)result;
1891 return jresult;
1892 }
1893
1894
1895 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1POSITION_1TOP_1get(JNIEnv *jenv, jclass jcls) {
1896 jint jresult = 0 ;
1897 int result;
1898
1899 (void)jenv;
1900 (void)jcls;
1901 result = (int)(0x4);
1902 jresult = (jint)result;
1903 return jresult;
1904 }
1905
1906
1907 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1POSITION_1BOTTOM_1get(JNIEnv *jenv, jclass jcls) {
1908 jint jresult = 0 ;
1909 int result;
1910
1911 (void)jenv;
1912 (void)jcls;
1913 result = (int)(0x8);
1914 jresult = (jint)result;
1915 return jresult;
1916 }
1917
1918
1919 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1POSITION_1INSIDE_1get(JNIEnv *jenv, jclass jcls) {
1920 jint jresult = 0 ;
1921 int result;
1922
1923 (void)jenv;
1924 (void)jcls;
1925 result = (int)(0x10);
1926 jresult = (jint)result;
1927 return jresult;
1928 }
1929
1930
1931 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1POSITION_1OUTSIDE_1get(JNIEnv *jenv, jclass jcls) {
1932 jint jresult = 0 ;
1933 int result;
1934
1935 (void)jenv;
1936 (void)jcls;
1937 result = (int)(0x20);
1938 jresult = (jint)result;
1939 return jresult;
1940 }
1941
1942
1943 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1POSITION_1VIEWPORT_1get(JNIEnv *jenv, jclass jcls) {
1944 jint jresult = 0 ;
1945 int result;
1946
1947 (void)jenv;
1948 (void)jcls;
1949 result = (int)(0x40);
1950 jresult = (jint)result;
1951 return jresult;
1952 }
1953
1954
1955 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1POSITION_1SUBPAGE_1get(JNIEnv *jenv, jclass jcls) {
1956 jint jresult = 0 ;
1957 int result;
1958
1959 (void)jenv;
1960 (void)jcls;
1961 result = (int)(0x80);
1962 jresult = (jint)result;
1963 return jresult;
1964 }
1965
1966
1967 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1LEGEND_1NONE_1get(JNIEnv *jenv, jclass jcls) {
1968 jint jresult = 0 ;
1969 int result;
1970
1971 (void)jenv;
1972 (void)jcls;
1973 result = (int)(0x1);
1974 jresult = (jint)result;
1975 return jresult;
1976 }
1977
1978
1979 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1LEGEND_1COLOR_1BOX_1get(JNIEnv *jenv, jclass jcls) {
1980 jint jresult = 0 ;
1981 int result;
1982
1983 (void)jenv;
1984 (void)jcls;
1985 result = (int)(0x2);
1986 jresult = (jint)result;
1987 return jresult;
1988 }
1989
1990
1991 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1LEGEND_1LINE_1get(JNIEnv *jenv, jclass jcls) {
1992 jint jresult = 0 ;
1993 int result;
1994
1995 (void)jenv;
1996 (void)jcls;
1997 result = (int)(0x4);
1998 jresult = (jint)result;
1999 return jresult;
2000 }
2001
2002
2003 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1LEGEND_1SYMBOL_1get(JNIEnv *jenv, jclass jcls) {
2004 jint jresult = 0 ;
2005 int result;
2006
2007 (void)jenv;
2008 (void)jcls;
2009 result = (int)(0x8);
2010 jresult = (jint)result;
2011 return jresult;
2012 }
2013
2014
2015 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1LEGEND_1TEXT_1LEFT_1get(JNIEnv *jenv, jclass jcls) {
2016 jint jresult = 0 ;
2017 int result;
2018
2019 (void)jenv;
2020 (void)jcls;
2021 result = (int)(0x10);
2022 jresult = (jint)result;
2023 return jresult;
2024 }
2025
2026
2027 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1LEGEND_1BACKGROUND_1get(JNIEnv *jenv, jclass jcls) {
2028 jint jresult = 0 ;
2029 int result;
2030
2031 (void)jenv;
2032 (void)jcls;
2033 result = (int)(0x20);
2034 jresult = (jint)result;
2035 return jresult;
2036 }
2037
2038
2039 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1LEGEND_1BOUNDING_1BOX_1get(JNIEnv *jenv, jclass jcls) {
2040 jint jresult = 0 ;
2041 int result;
2042
2043 (void)jenv;
2044 (void)jcls;
2045 result = (int)(0x40);
2046 jresult = (jint)result;
2047 return jresult;
2048 }
2049
2050
2051 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1LEGEND_1ROW_1MAJOR_1get(JNIEnv *jenv, jclass jcls) {
2052 jint jresult = 0 ;
2053 int result;
2054
2055 (void)jenv;
2056 (void)jcls;
2057 result = (int)(0x80);
2058 jresult = (jint)result;
2059 return jresult;
2060 }
2061
2062
2063 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1LABEL_1LEFT_1get(JNIEnv *jenv, jclass jcls) {
2064 jint jresult = 0 ;
2065 int result;
2066
2067 (void)jenv;
2068 (void)jcls;
2069 result = (int)(0x1);
2070 jresult = (jint)result;
2071 return jresult;
2072 }
2073
2074
2075 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1LABEL_1RIGHT_1get(JNIEnv *jenv, jclass jcls) {
2076 jint jresult = 0 ;
2077 int result;
2078
2079 (void)jenv;
2080 (void)jcls;
2081 result = (int)(0x2);
2082 jresult = (jint)result;
2083 return jresult;
2084 }
2085
2086
2087 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1LABEL_1TOP_1get(JNIEnv *jenv, jclass jcls) {
2088 jint jresult = 0 ;
2089 int result;
2090
2091 (void)jenv;
2092 (void)jcls;
2093 result = (int)(0x4);
2094 jresult = (jint)result;
2095 return jresult;
2096 }
2097
2098
2099 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1LABEL_1BOTTOM_1get(JNIEnv *jenv, jclass jcls) {
2100 jint jresult = 0 ;
2101 int result;
2102
2103 (void)jenv;
2104 (void)jcls;
2105 result = (int)(0x8);
2106 jresult = (jint)result;
2107 return jresult;
2108 }
2109
2110
2111 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1IMAGE_1get(JNIEnv *jenv, jclass jcls) {
2112 jint jresult = 0 ;
2113 int result;
2114
2115 (void)jenv;
2116 (void)jcls;
2117 result = (int)(0x10);
2118 jresult = (jint)result;
2119 return jresult;
2120 }
2121
2122
2123 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1SHADE_1get(JNIEnv *jenv, jclass jcls) {
2124 jint jresult = 0 ;
2125 int result;
2126
2127 (void)jenv;
2128 (void)jcls;
2129 result = (int)(0x20);
2130 jresult = (jint)result;
2131 return jresult;
2132 }
2133
2134
2135 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1GRADIENT_1get(JNIEnv *jenv, jclass jcls) {
2136 jint jresult = 0 ;
2137 int result;
2138
2139 (void)jenv;
2140 (void)jcls;
2141 result = (int)(0x40);
2142 jresult = (jint)result;
2143 return jresult;
2144 }
2145
2146
2147 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1CAP_1NONE_1get(JNIEnv *jenv, jclass jcls) {
2148 jint jresult = 0 ;
2149 int result;
2150
2151 (void)jenv;
2152 (void)jcls;
2153 result = (int)(0x80);
2154 jresult = (jint)result;
2155 return jresult;
2156 }
2157
2158
2159 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1CAP_1LOW_1get(JNIEnv *jenv, jclass jcls) {
2160 jint jresult = 0 ;
2161 int result;
2162
2163 (void)jenv;
2164 (void)jcls;
2165 result = (int)(0x100);
2166 jresult = (jint)result;
2167 return jresult;
2168 }
2169
2170
2171 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1CAP_1HIGH_1get(JNIEnv *jenv, jclass jcls) {
2172 jint jresult = 0 ;
2173 int result;
2174
2175 (void)jenv;
2176 (void)jcls;
2177 result = (int)(0x200);
2178 jresult = (jint)result;
2179 return jresult;
2180 }
2181
2182
2183 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1SHADE_1LABEL_1get(JNIEnv *jenv, jclass jcls) {
2184 jint jresult = 0 ;
2185 int result;
2186
2187 (void)jenv;
2188 (void)jcls;
2189 result = (int)(0x400);
2190 jresult = (jint)result;
2191 return jresult;
2192 }
2193
2194
2195 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1ORIENT_1RIGHT_1get(JNIEnv *jenv, jclass jcls) {
2196 jint jresult = 0 ;
2197 int result;
2198
2199 (void)jenv;
2200 (void)jcls;
2201 result = (int)(0x800);
2202 jresult = (jint)result;
2203 return jresult;
2204 }
2205
2206
2207 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1ORIENT_1TOP_1get(JNIEnv *jenv, jclass jcls) {
2208 jint jresult = 0 ;
2209 int result;
2210
2211 (void)jenv;
2212 (void)jcls;
2213 result = (int)(0x1000);
2214 jresult = (jint)result;
2215 return jresult;
2216 }
2217
2218
2219 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1ORIENT_1LEFT_1get(JNIEnv *jenv, jclass jcls) {
2220 jint jresult = 0 ;
2221 int result;
2222
2223 (void)jenv;
2224 (void)jcls;
2225 result = (int)(0x2000);
2226 jresult = (jint)result;
2227 return jresult;
2228 }
2229
2230
2231 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1ORIENT_1BOTTOM_1get(JNIEnv *jenv, jclass jcls) {
2232 jint jresult = 0 ;
2233 int result;
2234
2235 (void)jenv;
2236 (void)jcls;
2237 result = (int)(0x4000);
2238 jresult = (jint)result;
2239 return jresult;
2240 }
2241
2242
2243 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1BACKGROUND_1get(JNIEnv *jenv, jclass jcls) {
2244 jint jresult = 0 ;
2245 int result;
2246
2247 (void)jenv;
2248 (void)jcls;
2249 result = (int)(0x8000);
2250 jresult = (jint)result;
2251 return jresult;
2252 }
2253
2254
2255 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1COLORBAR_1BOUNDING_1BOX_1get(JNIEnv *jenv, jclass jcls) {
2256 jint jresult = 0 ;
2257 int result;
2258
2259 (void)jenv;
2260 (void)jcls;
2261 result = (int)(0x10000);
2262 jresult = (jint)result;
2263 return jresult;
2264 }
2265
2266
2267 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1DRAWMODE_1UNKNOWN_1get(JNIEnv *jenv, jclass jcls) {
2268 jint jresult = 0 ;
2269 int result;
2270
2271 (void)jenv;
2272 (void)jcls;
2273 result = (int)(0x0);
2274 jresult = (jint)result;
2275 return jresult;
2276 }
2277
2278
2279 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1DRAWMODE_1DEFAULT_1get(JNIEnv *jenv, jclass jcls) {
2280 jint jresult = 0 ;
2281 int result;
2282
2283 (void)jenv;
2284 (void)jcls;
2285 result = (int)(0x1);
2286 jresult = (jint)result;
2287 return jresult;
2288 }
2289
2290
2291 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1DRAWMODE_1REPLACE_1get(JNIEnv *jenv, jclass jcls) {
2292 jint jresult = 0 ;
2293 int result;
2294
2295 (void)jenv;
2296 (void)jcls;
2297 result = (int)(0x2);
2298 jresult = (jint)result;
2299 return jresult;
2300 }
2301
2302
2303 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PL_1DRAWMODE_1XOR_1get(JNIEnv *jenv, jclass jcls) {
2304 jint jresult = 0 ;
2305 int result;
2306
2307 (void)jenv;
2308 (void)jcls;
2309 result = (int)(0x4);
2310 jresult = (jint)result;
2311 return jresult;
2312 }
2313
2314
2315 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_DRAW_1LINEX_1get(JNIEnv *jenv, jclass jcls) {
2316 jint jresult = 0 ;
2317 int result;
2318
2319 (void)jenv;
2320 (void)jcls;
2321 result = (int)(0x001);
2322 jresult = (jint)result;
2323 return jresult;
2324 }
2325
2326
2327 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_DRAW_1LINEY_1get(JNIEnv *jenv, jclass jcls) {
2328 jint jresult = 0 ;
2329 int result;
2330
2331 (void)jenv;
2332 (void)jcls;
2333 result = (int)(0x002);
2334 jresult = (jint)result;
2335 return jresult;
2336 }
2337
2338
2339 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_DRAW_1LINEXY_1get(JNIEnv *jenv, jclass jcls) {
2340 jint jresult = 0 ;
2341 int result;
2342
2343 (void)jenv;
2344 (void)jcls;
2345 result = (int)(0x003);
2346 jresult = (jint)result;
2347 return jresult;
2348 }
2349
2350
2351 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_MAG_1COLOR_1get(JNIEnv *jenv, jclass jcls) {
2352 jint jresult = 0 ;
2353 int result;
2354
2355 (void)jenv;
2356 (void)jcls;
2357 result = (int)(0x004);
2358 jresult = (jint)result;
2359 return jresult;
2360 }
2361
2362
2363 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_BASE_1CONT_1get(JNIEnv *jenv, jclass jcls) {
2364 jint jresult = 0 ;
2365 int result;
2366
2367 (void)jenv;
2368 (void)jcls;
2369 result = (int)(0x008);
2370 jresult = (jint)result;
2371 return jresult;
2372 }
2373
2374
2375 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_TOP_1CONT_1get(JNIEnv *jenv, jclass jcls) {
2376 jint jresult = 0 ;
2377 int result;
2378
2379 (void)jenv;
2380 (void)jcls;
2381 result = (int)(0x010);
2382 jresult = (jint)result;
2383 return jresult;
2384 }
2385
2386
2387 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_SURF_1CONT_1get(JNIEnv *jenv, jclass jcls) {
2388 jint jresult = 0 ;
2389 int result;
2390
2391 (void)jenv;
2392 (void)jcls;
2393 result = (int)(0x020);
2394 jresult = (jint)result;
2395 return jresult;
2396 }
2397
2398
2399 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_DRAW_1SIDES_1get(JNIEnv *jenv, jclass jcls) {
2400 jint jresult = 0 ;
2401 int result;
2402
2403 (void)jenv;
2404 (void)jcls;
2405 result = (int)(0x040);
2406 jresult = (jint)result;
2407 return jresult;
2408 }
2409
2410
2411 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_FACETED_1get(JNIEnv *jenv, jclass jcls) {
2412 jint jresult = 0 ;
2413 int result;
2414
2415 (void)jenv;
2416 (void)jcls;
2417 result = (int)(0x080);
2418 jresult = (jint)result;
2419 return jresult;
2420 }
2421
2422
2423 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_MESH_1get(JNIEnv *jenv, jclass jcls) {
2424 jint jresult = 0 ;
2425 int result;
2426
2427 (void)jenv;
2428 (void)jcls;
2429 result = (int)(0x100);
2430 jresult = (jint)result;
2431 return jresult;
2432 }
2433
2434
2435 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1type_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) {
2436 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2437 int arg2 ;
2438
2439 (void)jenv;
2440 (void)jcls;
2441 arg1 = *(PLGraphicsIn **)&jarg1;
2442 arg2 = (int)jarg2;
2443 if (arg1) (arg1)->type = arg2;
2444 }
2445
2446
2447 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1type_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2448 jint jresult = 0 ;
2449 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2450 int result;
2451
2452 (void)jenv;
2453 (void)jcls;
2454 arg1 = *(PLGraphicsIn **)&jarg1;
2455 result = (int) ((arg1)->type);
2456 jresult = (jint)result;
2457 return jresult;
2458 }
2459
2460
2461 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1state_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) {
2462 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2463 unsigned int arg2 ;
2464
2465 (void)jenv;
2466 (void)jcls;
2467 arg1 = *(PLGraphicsIn **)&jarg1;
2468 arg2 = (unsigned int)jarg2;
2469 if (arg1) (arg1)->state = arg2;
2470 }
2471
2472
2473 SWIGEXPORT jlong JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1state_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2474 jlong jresult = 0 ;
2475 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2476 unsigned int result;
2477
2478 (void)jenv;
2479 (void)jcls;
2480 arg1 = *(PLGraphicsIn **)&jarg1;
2481 result = (unsigned int) ((arg1)->state);
2482 jresult = (jlong)result;
2483 return jresult;
2484 }
2485
2486
2487 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1keysym_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) {
2488 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2489 unsigned int arg2 ;
2490
2491 (void)jenv;
2492 (void)jcls;
2493 arg1 = *(PLGraphicsIn **)&jarg1;
2494 arg2 = (unsigned int)jarg2;
2495 if (arg1) (arg1)->keysym = arg2;
2496 }
2497
2498
2499 SWIGEXPORT jlong JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1keysym_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2500 jlong jresult = 0 ;
2501 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2502 unsigned int result;
2503
2504 (void)jenv;
2505 (void)jcls;
2506 arg1 = *(PLGraphicsIn **)&jarg1;
2507 result = (unsigned int) ((arg1)->keysym);
2508 jresult = (jlong)result;
2509 return jresult;
2510 }
2511
2512
2513 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1button_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) {
2514 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2515 unsigned int arg2 ;
2516
2517 (void)jenv;
2518 (void)jcls;
2519 arg1 = *(PLGraphicsIn **)&jarg1;
2520 arg2 = (unsigned int)jarg2;
2521 if (arg1) (arg1)->button = arg2;
2522 }
2523
2524
2525 SWIGEXPORT jlong JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1button_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2526 jlong jresult = 0 ;
2527 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2528 unsigned int result;
2529
2530 (void)jenv;
2531 (void)jcls;
2532 arg1 = *(PLGraphicsIn **)&jarg1;
2533 result = (unsigned int) ((arg1)->button);
2534 jresult = (jlong)result;
2535 return jresult;
2536 }
2537
2538
2539 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1subwindow_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) {
2540 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2541 PLINT arg2 ;
2542
2543 (void)jenv;
2544 (void)jcls;
2545 arg1 = *(PLGraphicsIn **)&jarg1;
2546 arg2 = (PLINT)jarg2;
2547 if (arg1) (arg1)->subwindow = arg2;
2548 }
2549
2550
2551 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1subwindow_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2552 jint jresult = 0 ;
2553 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2554 PLINT result;
2555
2556 (void)jenv;
2557 (void)jcls;
2558 arg1 = *(PLGraphicsIn **)&jarg1;
2559 result = (PLINT) ((arg1)->subwindow);
2560 jresult = (jint)result;
2561 return jresult;
2562 }
2563
2564
2565 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1string_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2) {
2566 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2567 char *arg2 ;
2568
2569 (void)jenv;
2570 (void)jcls;
2571 arg1 = *(PLGraphicsIn **)&jarg1;
2572 arg2 = 0;
2573 if (jarg2) {
2574 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);
2575 if (!arg2) return ;
2576 }
2577 {
2578 if(arg2) {
2579 strncpy((char*)arg1->string, (const char *)arg2, 16-1);
2580 arg1->string[16-1] = 0;
2581 } else {
2582 arg1->string[0] = 0;
2583 }
2584 }
2585
2586 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2);
2587 }
2588
2589
2590 SWIGEXPORT jstring JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1string_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2591 jstring jresult = 0 ;
2592 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2593 char *result = 0 ;
2594
2595 (void)jenv;
2596 (void)jcls;
2597 arg1 = *(PLGraphicsIn **)&jarg1;
2598 result = (char *)(char *) ((arg1)->string);
2599 if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result);
2600 return jresult;
2601 }
2602
2603
2604 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1pX_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) {
2605 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2606 int arg2 ;
2607
2608 (void)jenv;
2609 (void)jcls;
2610 arg1 = *(PLGraphicsIn **)&jarg1;
2611 arg2 = (int)jarg2;
2612 if (arg1) (arg1)->pX = arg2;
2613 }
2614
2615
2616 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1pX_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2617 jint jresult = 0 ;
2618 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2619 int result;
2620
2621 (void)jenv;
2622 (void)jcls;
2623 arg1 = *(PLGraphicsIn **)&jarg1;
2624 result = (int) ((arg1)->pX);
2625 jresult = (jint)result;
2626 return jresult;
2627 }
2628
2629
2630 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1pY_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) {
2631 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2632 int arg2 ;
2633
2634 (void)jenv;
2635 (void)jcls;
2636 arg1 = *(PLGraphicsIn **)&jarg1;
2637 arg2 = (int)jarg2;
2638 if (arg1) (arg1)->pY = arg2;
2639 }
2640
2641
2642 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1pY_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2643 jint jresult = 0 ;
2644 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2645 int result;
2646
2647 (void)jenv;
2648 (void)jcls;
2649 arg1 = *(PLGraphicsIn **)&jarg1;
2650 result = (int) ((arg1)->pY);
2651 jresult = (jint)result;
2652 return jresult;
2653 }
2654
2655
2656 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1dX_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jdouble jarg2) {
2657 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2658 PLFLT arg2 ;
2659
2660 (void)jenv;
2661 (void)jcls;
2662 arg1 = *(PLGraphicsIn **)&jarg1;
2663 arg2 = (PLFLT)jarg2;
2664 if (arg1) (arg1)->dX = arg2;
2665 }
2666
2667
2668 SWIGEXPORT jdouble JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1dX_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2669 jdouble jresult = 0 ;
2670 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2671 PLFLT result;
2672
2673 (void)jenv;
2674 (void)jcls;
2675 arg1 = *(PLGraphicsIn **)&jarg1;
2676 result = (PLFLT) ((arg1)->dX);
2677 jresult = (jdouble)result;
2678 return jresult;
2679 }
2680
2681
2682 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1dY_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jdouble jarg2) {
2683 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2684 PLFLT arg2 ;
2685
2686 (void)jenv;
2687 (void)jcls;
2688 arg1 = *(PLGraphicsIn **)&jarg1;
2689 arg2 = (PLFLT)jarg2;
2690 if (arg1) (arg1)->dY = arg2;
2691 }
2692
2693
2694 SWIGEXPORT jdouble JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1dY_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2695 jdouble jresult = 0 ;
2696 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2697 PLFLT result;
2698
2699 (void)jenv;
2700 (void)jcls;
2701 arg1 = *(PLGraphicsIn **)&jarg1;
2702 result = (PLFLT) ((arg1)->dY);
2703 jresult = (jdouble)result;
2704 return jresult;
2705 }
2706
2707
2708 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1wX_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jdouble jarg2) {
2709 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2710 PLFLT arg2 ;
2711
2712 (void)jenv;
2713 (void)jcls;
2714 arg1 = *(PLGraphicsIn **)&jarg1;
2715 arg2 = (PLFLT)jarg2;
2716 if (arg1) (arg1)->wX = arg2;
2717 }
2718
2719
2720 SWIGEXPORT jdouble JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1wX_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2721 jdouble jresult = 0 ;
2722 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2723 PLFLT result;
2724
2725 (void)jenv;
2726 (void)jcls;
2727 arg1 = *(PLGraphicsIn **)&jarg1;
2728 result = (PLFLT) ((arg1)->wX);
2729 jresult = (jdouble)result;
2730 return jresult;
2731 }
2732
2733
2734 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1wY_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jdouble jarg2) {
2735 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2736 PLFLT arg2 ;
2737
2738 (void)jenv;
2739 (void)jcls;
2740 arg1 = *(PLGraphicsIn **)&jarg1;
2741 arg2 = (PLFLT)jarg2;
2742 if (arg1) (arg1)->wY = arg2;
2743 }
2744
2745
2746 SWIGEXPORT jdouble JNICALL Java_plplot_core_plplotjavacJNI_PLGraphicsIn_1wY_1get(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2747 jdouble jresult = 0 ;
2748 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2749 PLFLT result;
2750
2751 (void)jenv;
2752 (void)jcls;
2753 arg1 = *(PLGraphicsIn **)&jarg1;
2754 result = (PLFLT) ((arg1)->wY);
2755 jresult = (jdouble)result;
2756 return jresult;
2757 }
2758
2759
2760 SWIGEXPORT jlong JNICALL Java_plplot_core_plplotjavacJNI_new_1PLGraphicsIn(JNIEnv *jenv, jclass jcls) {
2761 jlong jresult = 0 ;
2762 PLGraphicsIn *result = 0 ;
2763
2764 (void)jenv;
2765 (void)jcls;
2766 result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
2767 *(PLGraphicsIn **)&jresult = result;
2768 return jresult;
2769 }
2770
2771
2772 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_delete_1PLGraphicsIn(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2773 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
2774
2775 (void)jenv;
2776 (void)jcls;
2777 arg1 = *(PLGraphicsIn **)&jarg1;
2778 free((char *) arg1);
2779 }
2780
2781
2782 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pl_1setcontlabelformat(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {
2783 PLINT arg1 ;
2784 PLINT arg2 ;
2785
2786 (void)jenv;
2787 (void)jcls;
2788 arg1 = (PLINT)jarg1;
2789 arg2 = (PLINT)jarg2;
2790 pl_setcontlabelformat(arg1,arg2);
2791 }
2792
2793
2794 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pl_1setcontlabelparam(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jint jarg4) {
2795 PLFLT arg1 ;
2796 PLFLT arg2 ;
2797 PLFLT arg3 ;
2798 PLINT arg4 ;
2799
2800 (void)jenv;
2801 (void)jcls;
2802 arg1 = (PLFLT)jarg1;
2803 arg2 = (PLFLT)jarg2;
2804 arg3 = (PLFLT)jarg3;
2805 arg4 = (PLINT)jarg4;
2806 pl_setcontlabelparam(arg1,arg2,arg3,arg4);
2807 }
2808
2809
2810 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pladv(JNIEnv *jenv, jclass jcls, jint jarg1) {
2811 PLINT arg1 ;
2812
2813 (void)jenv;
2814 (void)jcls;
2815 arg1 = (PLINT)jarg1;
2816 pladv(arg1);
2817 }
2818
2819
2820 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) {
2821 PLFLT arg1 ;
2822 PLFLT arg2 ;
2823 PLFLT arg3 ;
2824 PLFLT arg4 ;
2825 PLFLT arg5 ;
2826 PLFLT arg6 ;
2827 PLFLT arg7 ;
2828 PLBOOL arg8 ;
2829
2830 (void)jenv;
2831 (void)jcls;
2832 arg1 = (PLFLT)jarg1;
2833 arg2 = (PLFLT)jarg2;
2834 arg3 = (PLFLT)jarg3;
2835 arg4 = (PLFLT)jarg4;
2836 arg5 = (PLFLT)jarg5;
2837 arg6 = (PLFLT)jarg6;
2838 arg7 = (PLFLT)jarg7;
2839
2840 arg8 = jarg8 ? 1 : 0;
2841
2842 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
2843 }
2844
2845
2846 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) {
2847 PLFLT arg1 ;
2848 PLFLT arg2 ;
2849 char *arg3 = (char *) 0 ;
2850 PLFLT arg4 ;
2851 PLINT arg5 ;
2852 char *arg6 = (char *) 0 ;
2853 PLFLT arg7 ;
2854 PLINT arg8 ;
2855
2856 (void)jenv;
2857 (void)jcls;
2858 arg1 = (PLFLT)jarg1;
2859 arg2 = (PLFLT)jarg2;
2860 arg3 = 0;
2861 if (jarg3) {
2862 arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0);
2863 if (!arg3) return ;
2864 }
2865 arg4 = (PLFLT)jarg4;
2866 arg5 = (PLINT)jarg5;
2867 arg6 = 0;
2868 if (jarg6) {
2869 arg6 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg6, 0);
2870 if (!arg6) return ;
2871 }
2872 arg7 = (PLFLT)jarg7;
2873 arg8 = (PLINT)jarg8;
2874 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
2875 if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3);
2876 if (arg6) (*jenv)->ReleaseStringUTFChars(jenv, jarg6, (const char *)arg6);
2877 }
2878
2879
2880 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plbin(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jint jarg4) {
2881 PLINT arg1 ;
2882 PLFLT *arg2 = (PLFLT *) 0 ;
2883 PLFLT *arg3 = (PLFLT *) 0 ;
2884 PLINT arg4 ;
2885
2886 (void)jenv;
2887 (void)jcls;
2888 {
2889 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
2890 arg1 = ( *jenv )->GetArrayLength( jenv, jarg1 );
2891 Alen = arg1;
2892 setup_array_1d_d( &arg2, jxdata, Alen );
2893 // Could find no easy way to do this as part of freearg so I modified
2894 // the previous function so it ALWAYS mallocs and copies so that
2895 // the java array can be released immediately.
2896 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
2897 }
2898 {
2899 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
2900 if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
2901 {
2902 printf( "Vectors must be same length.\n" );
2903 return;
2904 }
2905 setup_array_1d_d( &arg3, jydata, Alen );
2906 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
2907 }
2908 arg4 = (PLINT)jarg4;
2909 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
2910 {
2911 free( arg2 );
2912 }
2913 {
2914 free( arg3 );
2915 }
2916 }
2917
2918
2919 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) {
2920 PLINT *arg1 = (PLINT *) 0 ;
2921 PLINT *arg2 = (PLINT *) 0 ;
2922 PLINT *arg3 = (PLINT *) 0 ;
2923 PLINT *arg4 = (PLINT *) 0 ;
2924 PLINT *arg5 = (PLINT *) 0 ;
2925 PLFLT *arg6 = (PLFLT *) 0 ;
2926 PLFLT arg7 ;
2927 PLINT temp1 ;
2928 PLINT temp2 ;
2929 PLINT temp3 ;
2930 PLINT temp4 ;
2931 PLINT temp5 ;
2932 PLFLT temp6 ;
2933
2934 (void)jenv;
2935 (void)jcls;
2936 {
2937 if (!jarg1) {
2938 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
2939 return ;
2940 }
2941 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
2942 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
2943 return ;
2944 }
2945 temp1 = (PLINT)0;
2946 arg1 = &temp1;
2947 }
2948 {
2949 if (!jarg2) {
2950 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
2951 return ;
2952 }
2953 if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
2954 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
2955 return ;
2956 }
2957 temp2 = (PLINT)0;
2958 arg2 = &temp2;
2959 }
2960 {
2961 if (!jarg3) {
2962 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
2963 return ;
2964 }
2965 if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
2966 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
2967 return ;
2968 }
2969 temp3 = (PLINT)0;
2970 arg3 = &temp3;
2971 }
2972 {
2973 if (!jarg4) {
2974 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
2975 return ;
2976 }
2977 if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
2978 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
2979 return ;
2980 }
2981 temp4 = (PLINT)0;
2982 arg4 = &temp4;
2983 }
2984 {
2985 if (!jarg5) {
2986 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
2987 return ;
2988 }
2989 if ((*jenv)->GetArrayLength(jenv, jarg5) == 0) {
2990 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
2991 return ;
2992 }
2993 temp5 = (PLINT)0;
2994 arg5 = &temp5;
2995 }
2996 {
2997 if (!jarg6) {
2998 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
2999 return ;
3000 }
3001 if ((*jenv)->GetArrayLength(jenv, jarg6) == 0) {
3002 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
3003 return ;
3004 }
3005 temp6 = (PLFLT)0;
3006 arg6 = &temp6;
3007 }
3008 arg7 = (PLFLT)jarg7;
3009 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
3010 {
3011 jint jvalue = (jint)temp1;
3012 (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
3013 }
3014 {
3015 jint jvalue = (jint)temp2;
3016 (*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);
3017 }
3018 {
3019 jint jvalue = (jint)temp3;
3020 (*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);
3021 }
3022 {
3023 jint jvalue = (jint)temp4;
3024 (*jenv)->SetIntArrayRegion(jenv, jarg4, 0, 1, &jvalue);
3025 }
3026 {
3027 jint jvalue = (jint)temp5;
3028 (*jenv)->SetIntArrayRegion(jenv, jarg5, 0, 1, &jvalue);
3029 }
3030 {
3031 jdouble jvalue = (jdouble)temp6;
3032 (*jenv)->SetDoubleArrayRegion(jenv, jarg6, 0, 1, &jvalue);
3033 }
3034
3035
3036
3037
3038
3039
3040 }
3041
3042
3043 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plbop(JNIEnv *jenv, jclass jcls) {
3044 (void)jenv;
3045 (void)jcls;
3046 plbop();
3047 }
3048
3049
3050 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plbox(JNIEnv *jenv, jclass jcls, jstring jarg1, jdouble jarg2, jint jarg3, jstring jarg4, jdouble jarg5, jint jarg6) {
3051 char *arg1 = (char *) 0 ;
3052 PLFLT arg2 ;
3053 PLINT arg3 ;
3054 char *arg4 = (char *) 0 ;
3055 PLFLT arg5 ;
3056 PLINT arg6 ;
3057
3058 (void)jenv;
3059 (void)jcls;
3060 arg1 = 0;
3061 if (jarg1) {
3062 arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
3063 if (!arg1) return ;
3064 }
3065 arg2 = (PLFLT)jarg2;
3066 arg3 = (PLINT)jarg3;
3067 arg4 = 0;
3068 if (jarg4) {
3069 arg4 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg4, 0);
3070 if (!arg4) return ;
3071 }
3072 arg5 = (PLFLT)jarg5;
3073 arg6 = (PLINT)jarg6;
3074 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
3075 if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
3076 if (arg4) (*jenv)->ReleaseStringUTFChars(jenv, jarg4, (const char *)arg4);
3077 }
3078
3079
3080 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) {
3081 char *arg1 = (char *) 0 ;
3082 char *arg2 = (char *) 0 ;
3083 PLFLT arg3 ;
3084 PLINT arg4 ;
3085 char *arg5 = (char *) 0 ;
3086 char *arg6 = (char *) 0 ;
3087 PLFLT arg7 ;
3088 PLINT arg8 ;
3089 char *arg9 = (char *) 0 ;
3090 char *arg10 = (char *) 0 ;
3091 PLFLT arg11 ;
3092 PLINT arg12 ;
3093
3094 (void)jenv;
3095 (void)jcls;
3096 arg1 = 0;
3097 if (jarg1) {
3098 arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
3099 if (!arg1) return ;
3100 }
3101 arg2 = 0;
3102 if (jarg2) {
3103 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);
3104 if (!arg2) return ;
3105 }
3106 arg3 = (PLFLT)jarg3;
3107 arg4 = (PLINT)jarg4;
3108 arg5 = 0;
3109 if (jarg5) {
3110 arg5 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg5, 0);
3111 if (!arg5) return ;
3112 }
3113 arg6 = 0;
3114 if (jarg6) {
3115 arg6 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg6, 0);
3116 if (!arg6) return ;
3117 }
3118 arg7 = (PLFLT)jarg7;
3119 arg8 = (PLINT)jarg8;
3120 arg9 = 0;
3121 if (jarg9) {
3122 arg9 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg9, 0);
3123 if (!arg9) return ;
3124 }
3125 arg10 = 0;
3126 if (jarg10) {
3127 arg10 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg10, 0);
3128 if (!arg10) return ;
3129 }
3130 arg11 = (PLFLT)jarg11;
3131 arg12 = (PLINT)jarg12;
3132 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);
3133 if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
3134 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2);
3135 if (arg5) (*jenv)->ReleaseStringUTFChars(jenv, jarg5, (const char *)arg5);
3136 if (arg6) (*jenv)->ReleaseStringUTFChars(jenv, jarg6, (const char *)arg6);
3137 if (arg9) (*jenv)->ReleaseStringUTFChars(jenv, jarg9, (const char *)arg9);
3138 if (arg10) (*jenv)->ReleaseStringUTFChars(jenv, jarg10, (const char *)arg10);
3139 }
3140
3141
3142 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plcalc_1world(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdoubleArray jarg3, jdoubleArray jarg4, jintArray jarg5) {
3143 PLFLT arg1 ;
3144 PLFLT arg2 ;
3145 PLFLT *arg3 = (PLFLT *) 0 ;
3146 PLFLT *arg4 = (PLFLT *) 0 ;
3147 PLINT *arg5 = (PLINT *) 0 ;
3148 PLFLT temp3 ;
3149 PLFLT temp4 ;
3150 PLINT temp5 ;
3151
3152 (void)jenv;
3153 (void)jcls;
3154 arg1 = (PLFLT)jarg1;
3155 arg2 = (PLFLT)jarg2;
3156 {
3157 if (!jarg3) {
3158 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
3159 return ;
3160 }
3161 if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
3162 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
3163 return ;
3164 }
3165 temp3 = (PLFLT)0;
3166 arg3 = &temp3;
3167 }
3168 {
3169 if (!jarg4) {
3170 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
3171 return ;
3172 }
3173 if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
3174 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
3175 return ;
3176 }
3177 temp4 = (PLFLT)0;
3178 arg4 = &temp4;
3179 }
3180 {
3181 if (!jarg5) {
3182 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
3183 return ;
3184 }
3185 if ((*jenv)->GetArrayLength(jenv, jarg5) == 0) {
3186 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
3187 return ;
3188 }
3189 temp5 = (PLINT)0;
3190 arg5 = &temp5;
3191 }
3192 plcalc_world(arg1,arg2,arg3,arg4,arg5);
3193 {
3194 jdouble jvalue = (jdouble)temp3;
3195 (*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);
3196 }
3197 {
3198 jdouble jvalue = (jdouble)temp4;
3199 (*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);
3200 }
3201 {
3202 jint jvalue = (jint)temp5;
3203 (*jenv)->SetIntArrayRegion(jenv, jarg5, 0, 1, &jvalue);
3204 }
3205
3206
3207
3208 }
3209
3210
3211 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plclear(JNIEnv *jenv, jclass jcls) {
3212 (void)jenv;
3213 (void)jcls;
3214 plclear();
3215 }
3216
3217
3218 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plcol0(JNIEnv *jenv, jclass jcls, jint jarg1) {
3219 PLINT arg1 ;
3220
3221 (void)jenv;
3222 (void)jcls;
3223 arg1 = (PLINT)jarg1;
3224 plcol0(arg1);
3225 }
3226
3227
3228 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plcol1(JNIEnv *jenv, jclass jcls, jdouble jarg1) {
3229 PLFLT arg1 ;
3230
3231 (void)jenv;
3232 (void)jcls;
3233 arg1 = (PLFLT)jarg1;
3234 plcol1(arg1);
3235 }
3236
3237
3238 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) {
3239 PLFLT arg1 ;
3240 PLFLT arg2 ;
3241 PLFLT arg3 ;
3242 PLINT arg4 ;
3243 PLBOOL arg5 ;
3244 PLINT arg6 ;
3245 PLINT arg7 ;
3246 PLINT arg8 ;
3247 PLINT arg9 ;
3248 PLINT arg10 ;
3249 PLFLT arg11 ;
3250
3251 (void)jenv;
3252 (void)jcls;
3253 arg1 = (PLFLT)jarg1;
3254 arg2 = (PLFLT)jarg2;
3255 arg3 = (PLFLT)jarg3;
3256 arg4 = (PLINT)jarg4;
3257
3258 arg5 = jarg5 ? 1 : 0;
3259
3260 arg6 = (PLINT)jarg6;
3261 arg7 = (PLINT)jarg7;
3262 arg8 = (PLINT)jarg8;
3263 arg9 = (PLINT)jarg9;
3264 arg10 = (PLINT)jarg10;
3265 arg11 = (PLFLT)jarg11;
3266 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3267 }
3268
3269
3270 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) {
3271 PLFLT **arg1 = (PLFLT **) 0 ;
3272 PLINT arg2 ;
3273 PLINT arg3 ;
3274 PLINT arg4 ;
3275 PLINT arg5 ;
3276 PLINT arg6 ;
3277 PLINT arg7 ;
3278 PLFLT *arg8 = (PLFLT *) 0 ;
3279 PLINT arg9 ;
3280 pltr_func arg10 ;
3281 PLPointer arg11 = (PLPointer) 0 ;
3282
3283 (void)jenv;
3284 (void)jcls;
3285 {
3286 jdouble **adat;
3287 jobject *ai;
3288 int nx = ( *jenv )->GetArrayLength( jenv, jarg1 );
3289 int ny = -1;
3290 int i, j;
3291 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
3292 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
3293
3294 ( *jenv )->EnsureLocalCapacity( jenv, nx );
3295
3296 for ( i = 0; i < nx; i++ )
3297 {
3298 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg1, i );
3299 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
3300
3301 if ( ny == -1 )
3302 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
3303 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
3304 {
3305 printf( "Misshapen a array.\n" );
3306 for ( j = 0; j <= i; j++ )
3307 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
3308 free( adat );
3309 free( ai );
3310 return;
3311 }
3312 }
3313
3314 Xlen = nx;
3315 Ylen = ny;
3316 setup_array_2d_d( &arg1, adat, nx, ny );
3317 arg2 = nx;
3318 arg3 = ny;
3319 for ( i = 0; i < nx; i++ )
3320 {
3321 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
3322 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
3323 }
3324
3325 free( adat );
3326 free( ai );
3327 }
3328 arg4 = (PLINT)jarg4;
3329 arg5 = (PLINT)jarg5;
3330 arg6 = (PLINT)jarg6;
3331 arg7 = (PLINT)jarg7;
3332 {
3333 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg8, 0 );
3334 arg9 = ( *jenv )->GetArrayLength( jenv, jarg8 );
3335 setup_array_1d_d( &arg8, jxdata, arg9 );
3336 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg8, jxdata, 0 );
3337 }
3338 {
3339 jdouble **adat;
3340 jobject *ai;
3341 int nx = ( *jenv )->GetArrayLength( jenv, jarg10 );
3342 int ny = -1;
3343 int i, j;
3344 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
3345 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
3346
3347 ( *jenv )->EnsureLocalCapacity( jenv, nx );
3348
3349 for ( i = 0; i < nx; i++ )
3350 {
3351 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg10, i );
3352 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
3353
3354 if ( ny == -1 )
3355 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
3356 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
3357 {
3358 printf( "Misshapen a array.\n" );
3359 for ( j = 0; j <= i; j++ )
3360 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
3361 free( adat );
3362 free( ai );
3363 return;
3364 }
3365 }
3366
3367 if ( !( ( nx == Xlen && ny == Ylen ) || ( nx == Xlen && ny == 1 ) ) )
3368 {
3369 printf( "Xlen =%d, nx =%d, Ylen =%d, ny =%d\n", Xlen, nx, Ylen, ny );
3370 printf( "X vector or matrix must match matrix dimensions.\n" );
3371 for ( i = 0; i < nx; i++ )
3372 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
3373 free( adat );
3374 free( ai );
3375 return;
3376 }
3377 // Store whether second dimension is unity.
3378 Alen = ny;
3379 setup_array_2d_d( &xg, adat, nx, ny );
3380 for ( i = 0; i < nx; i++ )
3381 {
3382 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
3383 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
3384 }
3385
3386 free( adat );
3387 free( ai );
3388 arg10 = pltr2;
3389 }
3390 {
3391 jdouble **adat;
3392 jobject *ai;
3393 int nx = ( *jenv )->GetArrayLength( jenv, jarg11 );
3394 int ny = -1;
3395 int i, j;
3396 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
3397 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
3398
3399 ( *jenv )->EnsureLocalCapacity( jenv, nx );
3400
3401 for ( i = 0; i < nx; i++ )
3402 {
3403 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg11, i );
3404 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
3405
3406 if ( ny == -1 )
3407 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
3408 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
3409 {
3410 printf( "Misshapen a array.\n" );
3411 for ( j = 0; j <= i; j++ )
3412 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
3413 free( adat );
3414 free( ai );
3415 return;
3416 }
3417 }
3418
3419 if ( !( ( nx == Xlen && ny == Ylen ) || ( nx == Ylen && ny == 1 && ny == Alen ) ) )
3420 {
3421 printf( "Xlen =%d, nx =%d, Ylen =%d, Alen =%d, ny =%d\n",
3422 Xlen, nx, Ylen, Alen, ny );
3423 printf( "Y vector or matrix must match matrix dimensions.\n" );
3424 for ( i = 0; i < nx; i++ )
3425 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
3426 free( adat );
3427 free( ai );
3428 return;
3429 }
3430 setup_array_2d_d( &yg, adat, nx, ny );
3431 for ( i = 0; i < nx; i++ )
3432 {
3433 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
3434 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
3435 }
3436
3437 free( adat );
3438 free( ai );
3439 cgrid = (PLcGrid2 *) malloc( sizeof ( PLcGrid2 ) );
3440 cgrid->xg = xg;
3441 cgrid->yg = yg;
3442 cgrid->nx = nx;
3443 cgrid->ny = ny;
3444 arg11 = cgrid;
3445 }
3446 plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
3447 {
3448 free( arg1[0] );
3449 free( arg1 );
3450 }
3451 {
3452 free( arg8 );
3453 }
3454 {
3455 free( xg[0] );
3456 free( xg );
3457 }
3458 {
3459 free( yg[0] );
3460 free( yg );
3461 free( cgrid );
3462 }
3463 }
3464
3465
3466 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) {
3467 PLINT arg1 ;
3468 PLINT arg2 ;
3469 PLINT arg3 ;
3470 PLINT arg4 ;
3471 PLINT arg5 ;
3472 PLFLT arg6 ;
3473 PLFLT *arg7 = (PLFLT *) 0 ;
3474 PLFLT temp7 ;
3475
3476 (void)jenv;
3477 (void)jcls;
3478 arg1 = (PLINT)jarg1;
3479 arg2 = (PLINT)jarg2;
3480 arg3 = (PLINT)jarg3;
3481 arg4 = (PLINT)jarg4;
3482 arg5 = (PLINT)jarg5;
3483 arg6 = (PLFLT)jarg6;
3484 {
3485 if (!jarg7) {
3486 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
3487 return ;
3488 }
3489 if ((*jenv)->GetArrayLength(jenv, jarg7) == 0) {
3490 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
3491 return ;
3492 }
3493 temp7 = (PLFLT)0;
3494 arg7 = &temp7;
3495 }
3496 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
3497 {
3498 jdouble jvalue = (jdouble)temp7;
3499 (*jenv)->SetDoubleArrayRegion(jenv, jarg7, 0, 1, &jvalue);
3500 }
3501
3502 }
3503
3504
3505 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plcpstrm(JNIEnv *jenv, jclass jcls, jint jarg1, jboolean jarg2) {
3506 PLINT arg1 ;
3507 PLBOOL arg2 ;
3508
3509 (void)jenv;
3510 (void)jcls;
3511 arg1 = (PLINT)jarg1;
3512
3513 arg2 = jarg2 ? 1 : 0;
3514
3515 plcpstrm(arg1,arg2);
3516 }
3517
3518
3519 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plend(JNIEnv *jenv, jclass jcls) {
3520 (void)jenv;
3521 (void)jcls;
3522 plend();
3523 }
3524
3525
3526 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plend1(JNIEnv *jenv, jclass jcls) {
3527 (void)jenv;
3528 (void)jcls;
3529 plend1();
3530 }
3531
3532
3533 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plenv(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4, jint jarg5, jint jarg6) {
3534 PLFLT arg1 ;
3535 PLFLT arg2 ;
3536 PLFLT arg3 ;
3537 PLFLT arg4 ;
3538 PLINT arg5 ;
3539 PLINT arg6 ;
3540
3541 (void)jenv;
3542 (void)jcls;
3543 arg1 = (PLFLT)jarg1;
3544 arg2 = (PLFLT)jarg2;
3545 arg3 = (PLFLT)jarg3;
3546 arg4 = (PLFLT)jarg4;
3547 arg5 = (PLINT)jarg5;
3548 arg6 = (PLINT)jarg6;
3549 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
3550 }
3551
3552
3553 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plenv0(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4, jint jarg5, jint jarg6) {
3554 PLFLT arg1 ;
3555 PLFLT arg2 ;
3556 PLFLT arg3 ;
3557 PLFLT arg4 ;
3558 PLINT arg5 ;
3559 PLINT arg6 ;
3560
3561 (void)jenv;
3562 (void)jcls;
3563 arg1 = (PLFLT)jarg1;
3564 arg2 = (PLFLT)jarg2;
3565 arg3 = (PLFLT)jarg3;
3566 arg4 = (PLFLT)jarg4;
3567 arg5 = (PLINT)jarg5;
3568 arg6 = (PLINT)jarg6;
3569 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
3570 }
3571
3572
3573 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pleop(JNIEnv *jenv, jclass jcls) {
3574 (void)jenv;
3575 (void)jcls;
3576 pleop();
3577 }
3578
3579
3580 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plerrx(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jdoubleArray jarg4) {
3581 PLINT arg1 ;
3582 PLFLT *arg2 = (PLFLT *) 0 ;
3583 PLFLT *arg3 = (PLFLT *) 0 ;
3584 PLFLT *arg4 = (PLFLT *) 0 ;
3585
3586 (void)jenv;
3587 (void)jcls;
3588 {
3589 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
3590 arg1 = ( *jenv )->GetArrayLength( jenv, jarg1 );
3591 Alen = arg1;
3592 setup_array_1d_d( &arg2, jxdata, Alen );
3593 // Could find no easy way to do this as part of freearg so I modified
3594 // the previous function so it ALWAYS mallocs and copies so that
3595 // the java array can be released immediately.
3596 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
3597 }
3598 {
3599 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
3600 if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
3601 {
3602 printf( "Vectors must be same length.\n" );
3603 return;
3604 }
3605 setup_array_1d_d( &arg3, jydata, Alen );
3606 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
3607 }
3608 {
3609 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg4, 0 );
3610 if ( ( *jenv )->GetArrayLength( jenv, jarg4 ) != Alen )
3611 {
3612 printf( "Vectors must be same length.\n" );
3613 return;
3614 }
3615 setup_array_1d_d( &arg4, jydata, Alen );
3616 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );
3617 }
3618 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
3619 {
3620 free( arg2 );
3621 }
3622 {
3623 free( arg3 );
3624 }
3625 {
3626 free( arg4 );
3627 }
3628 }
3629
3630
3631 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plerry(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jdoubleArray jarg4) {
3632 PLINT arg1 ;
3633 PLFLT *arg2 = (PLFLT *) 0 ;
3634 PLFLT *arg3 = (PLFLT *) 0 ;
3635 PLFLT *arg4 = (PLFLT *) 0 ;
3636
3637 (void)jenv;
3638 (void)jcls;
3639 {
3640 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
3641 arg1 = ( *jenv )->GetArrayLength( jenv, jarg1 );
3642 Alen = arg1;
3643 setup_array_1d_d( &arg2, jxdata, Alen );
3644 // Could find no easy way to do this as part of freearg so I modified
3645 // the previous function so it ALWAYS mallocs and copies so that
3646 // the java array can be released immediately.
3647 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
3648 }
3649 {
3650 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
3651 if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
3652 {
3653 printf( "Vectors must be same length.\n" );
3654 return;
3655 }
3656 setup_array_1d_d( &arg3, jydata, Alen );
3657 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
3658 }
3659 {
3660 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg4, 0 );
3661 if ( ( *jenv )->GetArrayLength( jenv, jarg4 ) != Alen )
3662 {
3663 printf( "Vectors must be same length.\n" );
3664 return;
3665 }
3666 setup_array_1d_d( &arg4, jydata, Alen );
3667 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );
3668 }
3669 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
3670 {
3671 free( arg2 );
3672 }
3673 {
3674 free( arg3 );
3675 }
3676 {
3677 free( arg4 );
3678 }
3679 }
3680
3681
3682 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plfamadv(JNIEnv *jenv, jclass jcls) {
3683 (void)jenv;
3684 (void)jcls;
3685 plfamadv();
3686 }
3687
3688
3689 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plfill(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3) {
3690 PLINT arg1 ;
3691 PLFLT *arg2 = (PLFLT *) 0 ;
3692 PLFLT *arg3 = (PLFLT *) 0 ;
3693
3694 (void)jenv;
3695 (void)jcls;
3696 {
3697 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
3698 arg1 = ( *jenv )->GetArrayLength( jenv, jarg1 );
3699 Alen = arg1;
3700 setup_array_1d_d( &arg2, jxdata, Alen );
3701 // Could find no easy way to do this as part of freearg so I modified
3702 // the previous function so it ALWAYS mallocs and copies so that
3703 // the java array can be released immediately.
3704 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
3705 }
3706 {
3707 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
3708 if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
3709 {
3710 printf( "Vectors must be same length.\n" );
3711 return;
3712 }
3713 setup_array_1d_d( &arg3, jydata, Alen );
3714 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
3715 }
3716 plfill(arg1,(double const *)arg2,(double const *)arg3);
3717 {
3718 free( arg2 );
3719 }
3720 {
3721 free( arg3 );
3722 }
3723 }
3724
3725
3726 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plfill3(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jdoubleArray jarg4) {
3727 PLINT arg1 ;
3728 PLFLT *arg2 = (PLFLT *) 0 ;
3729 PLFLT *arg3 = (PLFLT *) 0 ;
3730 PLFLT *arg4 = (PLFLT *) 0 ;
3731
3732 (void)jenv;
3733 (void)jcls;
3734 {
3735 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
3736 arg1 = ( *jenv )->GetArrayLength( jenv, jarg1 );
3737 Alen = arg1;
3738 setup_array_1d_d( &arg2, jxdata, Alen );
3739 // Could find no easy way to do this as part of freearg so I modified
3740 // the previous function so it ALWAYS mallocs and copies so that
3741 // the java array can be released immediately.
3742 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
3743 }
3744 {
3745 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
3746 if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
3747 {
3748 printf( "Vectors must be same length.\n" );
3749 return;
3750 }
3751 setup_array_1d_d( &arg3, jydata, Alen );
3752 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
3753 }
3754 {
3755 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg4, 0 );
3756 if ( ( *jenv )->GetArrayLength( jenv, jarg4 ) != Alen )
3757 {
3758 printf( "Vectors must be same length.\n" );
3759 return;
3760 }
3761 setup_array_1d_d( &arg4, jydata, Alen );
3762 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );
3763 }
3764 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
3765 {
3766 free( arg2 );
3767 }
3768 {
3769 free( arg3 );
3770 }
3771 {
3772 free( arg4 );
3773 }
3774 }
3775
3776
3777 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgradient(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jdouble jarg4) {
3778 PLINT arg1 ;
3779 PLFLT *arg2 = (PLFLT *) 0 ;
3780 PLFLT *arg3 = (PLFLT *) 0 ;
3781 PLFLT arg4 ;
3782
3783 (void)jenv;
3784 (void)jcls;
3785 {
3786 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
3787 arg1 = ( *jenv )->GetArrayLength( jenv, jarg1 );
3788 Alen = arg1;
3789 setup_array_1d_d( &arg2, jxdata, Alen );
3790 // Could find no easy way to do this as part of freearg so I modified
3791 // the previous function so it ALWAYS mallocs and copies so that
3792 // the java array can be released immediately.
3793 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
3794 }
3795 {
3796 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
3797 if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
3798 {
3799 printf( "Vectors must be same length.\n" );
3800 return;
3801 }
3802 setup_array_1d_d( &arg3, jydata, Alen );
3803 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
3804 }
3805 arg4 = (PLFLT)jarg4;
3806 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
3807 {
3808 free( arg2 );
3809 }
3810 {
3811 free( arg3 );
3812 }
3813 }
3814
3815
3816 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plflush(JNIEnv *jenv, jclass jcls) {
3817 (void)jenv;
3818 (void)jcls;
3819 plflush();
3820 }
3821
3822
3823 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plfont(JNIEnv *jenv, jclass jcls, jint jarg1) {
3824 PLINT arg1 ;
3825
3826 (void)jenv;
3827 (void)jcls;
3828 arg1 = (PLINT)jarg1;
3829 plfont(arg1);
3830 }
3831
3832
3833 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plfontld(JNIEnv *jenv, jclass jcls, jint jarg1) {
3834 PLINT arg1 ;
3835
3836 (void)jenv;
3837 (void)jcls;
3838 arg1 = (PLINT)jarg1;
3839 plfontld(arg1);
3840 }
3841
3842
3843 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgchr(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2) {
3844 PLFLT *arg1 = (PLFLT *) 0 ;
3845 PLFLT *arg2 = (PLFLT *) 0 ;
3846 PLFLT temp1 ;
3847 PLFLT temp2 ;
3848
3849 (void)jenv;
3850 (void)jcls;
3851 {
3852 if (!jarg1) {
3853 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
3854 return ;
3855 }
3856 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
3857 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
3858 return ;
3859 }
3860 temp1 = (PLFLT)0;
3861 arg1 = &temp1;
3862 }
3863 {
3864 if (!jarg2) {
3865 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
3866 return ;
3867 }
3868 if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
3869 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
3870 return ;
3871 }
3872 temp2 = (PLFLT)0;
3873 arg2 = &temp2;
3874 }
3875 plgchr(arg1,arg2);
3876 {
3877 jdouble jvalue = (jdouble)temp1;
3878 (*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);
3879 }
3880 {
3881 jdouble jvalue = (jdouble)temp2;
3882 (*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);
3883 }
3884
3885
3886 }
3887
3888
3889 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgcol0(JNIEnv *jenv, jclass jcls, jint jarg1, jintArray jarg2, jintArray jarg3, jintArray jarg4) {
3890 PLINT arg1 ;
3891 PLINT *arg2 = (PLINT *) 0 ;
3892 PLINT *arg3 = (PLINT *) 0 ;
3893 PLINT *arg4 = (PLINT *) 0 ;
3894 PLINT temp2 ;
3895 PLINT temp3 ;
3896 PLINT temp4 ;
3897
3898 (void)jenv;
3899 (void)jcls;
3900 arg1 = (PLINT)jarg1;
3901 {
3902 if (!jarg2) {
3903 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
3904 return ;
3905 }
3906 if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
3907 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
3908 return ;
3909 }
3910 temp2 = (PLINT)0;
3911 arg2 = &temp2;
3912 }
3913 {
3914 if (!jarg3) {
3915 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
3916 return ;
3917 }
3918 if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
3919 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
3920 return ;
3921 }
3922 temp3 = (PLINT)0;
3923 arg3 = &temp3;
3924 }
3925 {
3926 if (!jarg4) {
3927 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
3928 return ;
3929 }
3930 if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
3931 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
3932 return ;
3933 }
3934 temp4 = (PLINT)0;
3935 arg4 = &temp4;
3936 }
3937 plgcol0(arg1,arg2,arg3,arg4);
3938 {
3939 jint jvalue = (jint)temp2;
3940 (*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);
3941 }
3942 {
3943 jint jvalue = (jint)temp3;
3944 (*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);
3945 }
3946 {
3947 jint jvalue = (jint)temp4;
3948 (*jenv)->SetIntArrayRegion(jenv, jarg4, 0, 1, &jvalue);
3949 }
3950
3951
3952
3953 }
3954
3955
3956 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgcol0a(JNIEnv *jenv, jclass jcls, jint jarg1, jintArray jarg2, jintArray jarg3, jintArray jarg4, jdoubleArray jarg5) {
3957 PLINT arg1 ;
3958 PLINT *arg2 = (PLINT *) 0 ;
3959 PLINT *arg3 = (PLINT *) 0 ;
3960 PLINT *arg4 = (PLINT *) 0 ;
3961 PLFLT *arg5 = (PLFLT *) 0 ;
3962 PLINT temp2 ;
3963 PLINT temp3 ;
3964 PLINT temp4 ;
3965 PLFLT temp5 ;
3966
3967 (void)jenv;
3968 (void)jcls;
3969 arg1 = (PLINT)jarg1;
3970 {
3971 if (!jarg2) {
3972 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
3973 return ;
3974 }
3975 if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
3976 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
3977 return ;
3978 }
3979 temp2 = (PLINT)0;
3980 arg2 = &temp2;
3981 }
3982 {
3983 if (!jarg3) {
3984 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
3985 return ;
3986 }
3987 if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
3988 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
3989 return ;
3990 }
3991 temp3 = (PLINT)0;
3992 arg3 = &temp3;
3993 }
3994 {
3995 if (!jarg4) {
3996 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
3997 return ;
3998 }
3999 if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
4000 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4001 return ;
4002 }
4003 temp4 = (PLINT)0;
4004 arg4 = &temp4;
4005 }
4006 {
4007 if (!jarg5) {
4008 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4009 return ;
4010 }
4011 if ((*jenv)->GetArrayLength(jenv, jarg5) == 0) {
4012 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4013 return ;
4014 }
4015 temp5 = (PLFLT)0;
4016 arg5 = &temp5;
4017 }
4018 plgcol0a(arg1,arg2,arg3,arg4,arg5);
4019 {
4020 jint jvalue = (jint)temp2;
4021 (*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);
4022 }
4023 {
4024 jint jvalue = (jint)temp3;
4025 (*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);
4026 }
4027 {
4028 jint jvalue = (jint)temp4;
4029 (*jenv)->SetIntArrayRegion(jenv, jarg4, 0, 1, &jvalue);
4030 }
4031 {
4032 jdouble jvalue = (jdouble)temp5;
4033 (*jenv)->SetDoubleArrayRegion(jenv, jarg5, 0, 1, &jvalue);
4034 }
4035
4036
4037
4038
4039 }
4040
4041
4042 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgcolbg(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2, jintArray jarg3) {
4043 PLINT *arg1 = (PLINT *) 0 ;
4044 PLINT *arg2 = (PLINT *) 0 ;
4045 PLINT *arg3 = (PLINT *) 0 ;
4046 PLINT temp1 ;
4047 PLINT temp2 ;
4048 PLINT temp3 ;
4049
4050 (void)jenv;
4051 (void)jcls;
4052 {
4053 if (!jarg1) {
4054 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4055 return ;
4056 }
4057 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
4058 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4059 return ;
4060 }
4061 temp1 = (PLINT)0;
4062 arg1 = &temp1;
4063 }
4064 {
4065 if (!jarg2) {
4066 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4067 return ;
4068 }
4069 if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
4070 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4071 return ;
4072 }
4073 temp2 = (PLINT)0;
4074 arg2 = &temp2;
4075 }
4076 {
4077 if (!jarg3) {
4078 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4079 return ;
4080 }
4081 if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
4082 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4083 return ;
4084 }
4085 temp3 = (PLINT)0;
4086 arg3 = &temp3;
4087 }
4088 plgcolbg(arg1,arg2,arg3);
4089 {
4090 jint jvalue = (jint)temp1;
4091 (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
4092 }
4093 {
4094 jint jvalue = (jint)temp2;
4095 (*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);
4096 }
4097 {
4098 jint jvalue = (jint)temp3;
4099 (*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);
4100 }
4101
4102
4103
4104 }
4105
4106
4107 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgcolbga(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2, jintArray jarg3, jdoubleArray jarg4) {
4108 PLINT *arg1 = (PLINT *) 0 ;
4109 PLINT *arg2 = (PLINT *) 0 ;
4110 PLINT *arg3 = (PLINT *) 0 ;
4111 PLFLT *arg4 = (PLFLT *) 0 ;
4112 PLINT temp1 ;
4113 PLINT temp2 ;
4114 PLINT temp3 ;
4115 PLFLT temp4 ;
4116
4117 (void)jenv;
4118 (void)jcls;
4119 {
4120 if (!jarg1) {
4121 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4122 return ;
4123 }
4124 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
4125 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4126 return ;
4127 }
4128 temp1 = (PLINT)0;
4129 arg1 = &temp1;
4130 }
4131 {
4132 if (!jarg2) {
4133 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4134 return ;
4135 }
4136 if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
4137 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4138 return ;
4139 }
4140 temp2 = (PLINT)0;
4141 arg2 = &temp2;
4142 }
4143 {
4144 if (!jarg3) {
4145 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4146 return ;
4147 }
4148 if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
4149 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4150 return ;
4151 }
4152 temp3 = (PLINT)0;
4153 arg3 = &temp3;
4154 }
4155 {
4156 if (!jarg4) {
4157 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4158 return ;
4159 }
4160 if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
4161 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4162 return ;
4163 }
4164 temp4 = (PLFLT)0;
4165 arg4 = &temp4;
4166 }
4167 plgcolbga(arg1,arg2,arg3,arg4);
4168 {
4169 jint jvalue = (jint)temp1;
4170 (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
4171 }
4172 {
4173 jint jvalue = (jint)temp2;
4174 (*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);
4175 }
4176 {
4177 jint jvalue = (jint)temp3;
4178 (*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);
4179 }
4180 {
4181 jdouble jvalue = (jdouble)temp4;
4182 (*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);
4183 }
4184
4185
4186
4187
4188 }
4189
4190
4191 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgcompression(JNIEnv *jenv, jclass jcls, jintArray jarg1) {
4192 PLINT *arg1 = (PLINT *) 0 ;
4193 PLINT temp1 ;
4194
4195 (void)jenv;
4196 (void)jcls;
4197 {
4198 if (!jarg1) {
4199 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4200 return ;
4201 }
4202 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
4203 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4204 return ;
4205 }
4206 temp1 = (PLINT)0;
4207 arg1 = &temp1;
4208 }
4209 plgcompression(arg1);
4210 {
4211 jint jvalue = (jint)temp1;
4212 (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
4213 }
4214
4215 }
4216
4217
4218 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgdev(JNIEnv *jenv, jclass jcls, jobject jarg1) {
4219 char *arg1 = (char *) 0 ;
4220
4221 (void)jenv;
4222 (void)jcls;
4223 {
4224 arg1 = NULL;
4225 if ( jarg1 != NULL )
4226 {
4227 // Get the String from the StringBuffer
4228 jmethodID setLengthID;
4229 jclass sbufClass = ( *jenv )->GetObjectClass( jenv, jarg1 );
4230 // Take a copy of the C string as the typemap is for a non const C string
4231 jmethodID capacityID = ( *jenv )->GetMethodID( jenv, sbufClass, "capacity", "()I" );
4232 jint capacity = ( *jenv )->CallIntMethod( jenv, jarg1, capacityID );
4233 arg1 = (char *) malloc( (size_t) ( capacity + 1 ) );
4234
4235 // Zero the original StringBuffer, so we can replace it with the result
4236 setLengthID = ( *jenv )->GetMethodID( jenv, sbufClass, "setLength", "(I)V" );
4237 ( *jenv )->CallVoidMethod( jenv, jarg1, setLengthID, (jint) 0 );
4238 }
4239 }
4240 plgdev(arg1);
4241 {
4242 if ( arg1 != NULL )
4243 {
4244 // Append the result to the empty StringBuffer
4245 jstring newString = ( *jenv )->NewStringUTF( jenv, arg1 );
4246 jclass sbufClass = ( *jenv )->GetObjectClass( jenv, jarg1 );
4247 jmethodID appendStringID = ( *jenv )->GetMethodID( jenv, sbufClass, "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;" );
4248 ( *jenv )->CallObjectMethod( jenv, jarg1, appendStringID, newString );
4249
4250 // Clean up the string object, no longer needed
4251 free( arg1 );
4252 arg1 = NULL;
4253 }
4254 }
4255
4256 }
4257
4258
4259 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgdidev(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jdoubleArray jarg3, jdoubleArray jarg4) {
4260 PLFLT *arg1 = (PLFLT *) 0 ;
4261 PLFLT *arg2 = (PLFLT *) 0 ;
4262 PLFLT *arg3 = (PLFLT *) 0 ;
4263 PLFLT *arg4 = (PLFLT *) 0 ;
4264 PLFLT temp1 ;
4265 PLFLT temp2 ;
4266 PLFLT temp3 ;
4267 PLFLT temp4 ;
4268
4269 (void)jenv;
4270 (void)jcls;
4271 {
4272 if (!jarg1) {
4273 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4274 return ;
4275 }
4276 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
4277 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4278 return ;
4279 }
4280 temp1 = (PLFLT)0;
4281 arg1 = &temp1;
4282 }
4283 {
4284 if (!jarg2) {
4285 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4286 return ;
4287 }
4288 if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
4289 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4290 return ;
4291 }
4292 temp2 = (PLFLT)0;
4293 arg2 = &temp2;
4294 }
4295 {
4296 if (!jarg3) {
4297 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4298 return ;
4299 }
4300 if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
4301 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4302 return ;
4303 }
4304 temp3 = (PLFLT)0;
4305 arg3 = &temp3;
4306 }
4307 {
4308 if (!jarg4) {
4309 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4310 return ;
4311 }
4312 if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
4313 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4314 return ;
4315 }
4316 temp4 = (PLFLT)0;
4317 arg4 = &temp4;
4318 }
4319 plgdidev(arg1,arg2,arg3,arg4);
4320 {
4321 jdouble jvalue = (jdouble)temp1;
4322 (*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);
4323 }
4324 {
4325 jdouble jvalue = (jdouble)temp2;
4326 (*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);
4327 }
4328 {
4329 jdouble jvalue = (jdouble)temp3;
4330 (*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);
4331 }
4332 {
4333 jdouble jvalue = (jdouble)temp4;
4334 (*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);
4335 }
4336
4337
4338
4339
4340 }
4341
4342
4343 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgdiori(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1) {
4344 PLFLT *arg1 = (PLFLT *) 0 ;
4345 PLFLT temp1 ;
4346
4347 (void)jenv;
4348 (void)jcls;
4349 {
4350 if (!jarg1) {
4351 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4352 return ;
4353 }
4354 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
4355 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4356 return ;
4357 }
4358 temp1 = (PLFLT)0;
4359 arg1 = &temp1;
4360 }
4361 plgdiori(arg1);
4362 {
4363 jdouble jvalue = (jdouble)temp1;
4364 (*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);
4365 }
4366
4367 }
4368
4369
4370 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgdiplt(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jdoubleArray jarg3, jdoubleArray jarg4) {
4371 PLFLT *arg1 = (PLFLT *) 0 ;
4372 PLFLT *arg2 = (PLFLT *) 0 ;
4373 PLFLT *arg3 = (PLFLT *) 0 ;
4374 PLFLT *arg4 = (PLFLT *) 0 ;
4375 PLFLT temp1 ;
4376 PLFLT temp2 ;
4377 PLFLT temp3 ;
4378 PLFLT temp4 ;
4379
4380 (void)jenv;
4381 (void)jcls;
4382 {
4383 if (!jarg1) {
4384 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4385 return ;
4386 }
4387 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
4388 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4389 return ;
4390 }
4391 temp1 = (PLFLT)0;
4392 arg1 = &temp1;
4393 }
4394 {
4395 if (!jarg2) {
4396 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4397 return ;
4398 }
4399 if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
4400 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4401 return ;
4402 }
4403 temp2 = (PLFLT)0;
4404 arg2 = &temp2;
4405 }
4406 {
4407 if (!jarg3) {
4408 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4409 return ;
4410 }
4411 if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
4412 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4413 return ;
4414 }
4415 temp3 = (PLFLT)0;
4416 arg3 = &temp3;
4417 }
4418 {
4419 if (!jarg4) {
4420 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4421 return ;
4422 }
4423 if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
4424 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4425 return ;
4426 }
4427 temp4 = (PLFLT)0;
4428 arg4 = &temp4;
4429 }
4430 plgdiplt(arg1,arg2,arg3,arg4);
4431 {
4432 jdouble jvalue = (jdouble)temp1;
4433 (*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);
4434 }
4435 {
4436 jdouble jvalue = (jdouble)temp2;
4437 (*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);
4438 }
4439 {
4440 jdouble jvalue = (jdouble)temp3;
4441 (*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);
4442 }
4443 {
4444 jdouble jvalue = (jdouble)temp4;
4445 (*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);
4446 }
4447
4448
4449
4450
4451 }
4452
4453
4454 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgfam(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2, jintArray jarg3) {
4455 PLINT *arg1 = (PLINT *) 0 ;
4456 PLINT *arg2 = (PLINT *) 0 ;
4457 PLINT *arg3 = (PLINT *) 0 ;
4458 PLINT temp1 ;
4459 PLINT temp2 ;
4460 PLINT temp3 ;
4461
4462 (void)jenv;
4463 (void)jcls;
4464 {
4465 if (!jarg1) {
4466 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4467 return ;
4468 }
4469 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
4470 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4471 return ;
4472 }
4473 temp1 = (PLINT)0;
4474 arg1 = &temp1;
4475 }
4476 {
4477 if (!jarg2) {
4478 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4479 return ;
4480 }
4481 if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
4482 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4483 return ;
4484 }
4485 temp2 = (PLINT)0;
4486 arg2 = &temp2;
4487 }
4488 {
4489 if (!jarg3) {
4490 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4491 return ;
4492 }
4493 if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
4494 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4495 return ;
4496 }
4497 temp3 = (PLINT)0;
4498 arg3 = &temp3;
4499 }
4500 plgfam(arg1,arg2,arg3);
4501 {
4502 jint jvalue = (jint)temp1;
4503 (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
4504 }
4505 {
4506 jint jvalue = (jint)temp2;
4507 (*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);
4508 }
4509 {
4510 jint jvalue = (jint)temp3;
4511 (*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);
4512 }
4513
4514
4515
4516 }
4517
4518
4519 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgfci(JNIEnv *jenv, jclass jcls, jlongArray jarg1) {
4520 PLUNICODE *arg1 = (PLUNICODE *) 0 ;
4521 PLUNICODE temp1 ;
4522
4523 (void)jenv;
4524 (void)jcls;
4525 {
4526 if (!jarg1) {
4527 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4528 return ;
4529 }
4530 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
4531 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4532 return ;
4533 }
4534 temp1 = (PLUNICODE)0;
4535 arg1 = &temp1;
4536 }
4537 plgfci(arg1);
4538 {
4539 jlong jvalue = (jlong)temp1;
4540 (*jenv)->SetLongArrayRegion(jenv, jarg1, 0, 1, &jvalue);
4541 }
4542
4543 }
4544
4545
4546 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgfnam(JNIEnv *jenv, jclass jcls, jobject jarg1) {
4547 char *arg1 = (char *) 0 ;
4548
4549 (void)jenv;
4550 (void)jcls;
4551 {
4552 arg1 = NULL;
4553 if ( jarg1 != NULL )
4554 {
4555 // Get the String from the StringBuffer
4556 jmethodID setLengthID;
4557 jclass sbufClass = ( *jenv )->GetObjectClass( jenv, jarg1 );
4558 // Take a copy of the C string as the typemap is for a non const C string
4559 jmethodID capacityID = ( *jenv )->GetMethodID( jenv, sbufClass, "capacity", "()I" );
4560 jint capacity = ( *jenv )->CallIntMethod( jenv, jarg1, capacityID );
4561 arg1 = (char *) malloc( (size_t) ( capacity + 1 ) );
4562
4563 // Zero the original StringBuffer, so we can replace it with the result
4564 setLengthID = ( *jenv )->GetMethodID( jenv, sbufClass, "setLength", "(I)V" );
4565 ( *jenv )->CallVoidMethod( jenv, jarg1, setLengthID, (jint) 0 );
4566 }
4567 }
4568 plgfnam(arg1);
4569 {
4570 if ( arg1 != NULL )
4571 {
4572 // Append the result to the empty StringBuffer
4573 jstring newString = ( *jenv )->NewStringUTF( jenv, arg1 );
4574 jclass sbufClass = ( *jenv )->GetObjectClass( jenv, jarg1 );
4575 jmethodID appendStringID = ( *jenv )->GetMethodID( jenv, sbufClass, "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;" );
4576 ( *jenv )->CallObjectMethod( jenv, jarg1, appendStringID, newString );
4577
4578 // Clean up the string object, no longer needed
4579 free( arg1 );
4580 arg1 = NULL;
4581 }
4582 }
4583
4584 }
4585
4586
4587 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgfont(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2, jintArray jarg3) {
4588 PLINT *arg1 = (PLINT *) 0 ;
4589 PLINT *arg2 = (PLINT *) 0 ;
4590 PLINT *arg3 = (PLINT *) 0 ;
4591 PLINT temp1 ;
4592 PLINT temp2 ;
4593 PLINT temp3 ;
4594
4595 (void)jenv;
4596 (void)jcls;
4597 {
4598 if (!jarg1) {
4599 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4600 return ;
4601 }
4602 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
4603 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4604 return ;
4605 }
4606 temp1 = (PLINT)0;
4607 arg1 = &temp1;
4608 }
4609 {
4610 if (!jarg2) {
4611 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4612 return ;
4613 }
4614 if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
4615 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4616 return ;
4617 }
4618 temp2 = (PLINT)0;
4619 arg2 = &temp2;
4620 }
4621 {
4622 if (!jarg3) {
4623 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4624 return ;
4625 }
4626 if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
4627 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4628 return ;
4629 }
4630 temp3 = (PLINT)0;
4631 arg3 = &temp3;
4632 }
4633 plgfont(arg1,arg2,arg3);
4634 {
4635 jint jvalue = (jint)temp1;
4636 (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
4637 }
4638 {
4639 jint jvalue = (jint)temp2;
4640 (*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);
4641 }
4642 {
4643 jint jvalue = (jint)temp3;
4644 (*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);
4645 }
4646
4647
4648
4649 }
4650
4651
4652 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plglevel(JNIEnv *jenv, jclass jcls, jintArray jarg1) {
4653 PLINT *arg1 = (PLINT *) 0 ;
4654 PLINT temp1 ;
4655
4656 (void)jenv;
4657 (void)jcls;
4658 {
4659 if (!jarg1) {
4660 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4661 return ;
4662 }
4663 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
4664 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4665 return ;
4666 }
4667 temp1 = (PLINT)0;
4668 arg1 = &temp1;
4669 }
4670 plglevel(arg1);
4671 {
4672 jint jvalue = (jint)temp1;
4673 (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
4674 }
4675
4676 }
4677
4678
4679 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgpage(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jintArray jarg3, jintArray jarg4, jintArray jarg5, jintArray jarg6) {
4680 PLFLT *arg1 = (PLFLT *) 0 ;
4681 PLFLT *arg2 = (PLFLT *) 0 ;
4682 PLINT *arg3 = (PLINT *) 0 ;
4683 PLINT *arg4 = (PLINT *) 0 ;
4684 PLINT *arg5 = (PLINT *) 0 ;
4685 PLINT *arg6 = (PLINT *) 0 ;
4686 PLFLT temp1 ;
4687 PLFLT temp2 ;
4688 PLINT temp3 ;
4689 PLINT temp4 ;
4690 PLINT temp5 ;
4691 PLINT temp6 ;
4692
4693 (void)jenv;
4694 (void)jcls;
4695 {
4696 if (!jarg1) {
4697 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4698 return ;
4699 }
4700 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
4701 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4702 return ;
4703 }
4704 temp1 = (PLFLT)0;
4705 arg1 = &temp1;
4706 }
4707 {
4708 if (!jarg2) {
4709 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4710 return ;
4711 }
4712 if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
4713 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4714 return ;
4715 }
4716 temp2 = (PLFLT)0;
4717 arg2 = &temp2;
4718 }
4719 {
4720 if (!jarg3) {
4721 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4722 return ;
4723 }
4724 if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
4725 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4726 return ;
4727 }
4728 temp3 = (PLINT)0;
4729 arg3 = &temp3;
4730 }
4731 {
4732 if (!jarg4) {
4733 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4734 return ;
4735 }
4736 if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
4737 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4738 return ;
4739 }
4740 temp4 = (PLINT)0;
4741 arg4 = &temp4;
4742 }
4743 {
4744 if (!jarg5) {
4745 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4746 return ;
4747 }
4748 if ((*jenv)->GetArrayLength(jenv, jarg5) == 0) {
4749 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4750 return ;
4751 }
4752 temp5 = (PLINT)0;
4753 arg5 = &temp5;
4754 }
4755 {
4756 if (!jarg6) {
4757 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4758 return ;
4759 }
4760 if ((*jenv)->GetArrayLength(jenv, jarg6) == 0) {
4761 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4762 return ;
4763 }
4764 temp6 = (PLINT)0;
4765 arg6 = &temp6;
4766 }
4767 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
4768 {
4769 jdouble jvalue = (jdouble)temp1;
4770 (*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);
4771 }
4772 {
4773 jdouble jvalue = (jdouble)temp2;
4774 (*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);
4775 }
4776 {
4777 jint jvalue = (jint)temp3;
4778 (*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);
4779 }
4780 {
4781 jint jvalue = (jint)temp4;
4782 (*jenv)->SetIntArrayRegion(jenv, jarg4, 0, 1, &jvalue);
4783 }
4784 {
4785 jint jvalue = (jint)temp5;
4786 (*jenv)->SetIntArrayRegion(jenv, jarg5, 0, 1, &jvalue);
4787 }
4788 {
4789 jint jvalue = (jint)temp6;
4790 (*jenv)->SetIntArrayRegion(jenv, jarg6, 0, 1, &jvalue);
4791 }
4792
4793
4794
4795
4796
4797
4798 }
4799
4800
4801 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgra(JNIEnv *jenv, jclass jcls) {
4802 (void)jenv;
4803 (void)jcls;
4804 plgra();
4805 }
4806
4807
4808 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) {
4809 PLFLT *arg1 = (PLFLT *) 0 ;
4810 PLFLT *arg2 = (PLFLT *) 0 ;
4811 PLFLT *arg3 = (PLFLT *) 0 ;
4812 PLINT arg4 ;
4813 PLFLT *arg5 = (PLFLT *) 0 ;
4814 PLINT arg6 ;
4815 PLFLT *arg7 = (PLFLT *) 0 ;
4816 PLINT arg8 ;
4817 PLFLT **arg9 = (PLFLT **) 0 ;
4818 PLINT arg10 ;
4819 PLFLT arg11 ;
4820
4821 (void)jenv;
4822 (void)jcls;
4823 {
4824 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
4825 Alen = ( *jenv )->GetArrayLength( jenv, jarg1 );
4826 setup_array_1d_d( &arg1, jxdata, Alen );
4827 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
4828 }
4829 {
4830 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg2, 0 );
4831 if ( ( *jenv )->GetArrayLength( jenv, jarg2 ) != Alen )
4832 {
4833 printf( "Vectors must be same length.\n" );
4834 return;
4835 }
4836 setup_array_1d_d( &arg2, jydata, Alen );
4837 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );
4838 }
4839 {
4840 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
4841 arg4 = ( *jenv )->GetArrayLength( jenv, jarg3 );
4842 if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
4843 {
4844 printf( "Vectors must be same length.\n" );
4845 return;
4846 }
4847 setup_array_1d_d( &arg3, jydata, Alen );
4848 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
4849 }
4850 {
4851 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg5, 0 );
4852 Xlen = ( *jenv )->GetArrayLength( jenv, jarg5 );
4853 arg6 = Xlen;
4854 setup_array_1d_d( &arg5, jxdata, Xlen );
4855 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg5, jxdata, 0 );
4856 }
4857 {
4858 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg7, 0 );
4859 Ylen = ( *jenv )->GetArrayLength( jenv, jarg7 );
4860 arg8 = Ylen;
4861 setup_array_1d_d( &arg7, jydata, Ylen );
4862 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg7, jydata, 0 );
4863 }
4864 {
4865 jobject ai;
4866 PLFLT **ptr;
4867 int nx = ( *jenv )->GetArrayLength( jenv, jarg9 );
4868 int ny = -1;
4869 int i;
4870
4871 ( *jenv )->EnsureLocalCapacity( jenv, nx );
4872
4873 for ( i = 0; i < nx; i++ )
4874 {
4875 ai = ( *jenv )->GetObjectArrayElement( jenv, jarg9, i );
4876
4877 if ( ny == -1 )
4878 ny = ( *jenv )->GetArrayLength( jenv, ai );
4879 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai ) )
4880 {
4881 printf( "Misshapen a array.\n" );
4882 return;
4883 }
4884 }
4885
4886 if ( nx != Xlen || ny != Ylen )
4887 {
4888 printf( "Vectors must match matrix.\n" );
4889 return;
4890 }
4891
4892 ptr = (PLFLT **) malloc( (size_t) nx * sizeof ( PLFLT * ) );
4893 ptr[0] = (PLFLT *) malloc( (size_t) nx * ny * sizeof ( PLFLT ) );
4894 for ( i = 0; i < nx; i++ )
4895 {
4896 ptr[i] = ptr[0] + i * ny;
4897 }
4898
4899 arg9 = ptr;
4900 }
4901 arg10 = (PLINT)jarg10;
4902 arg11 = (PLFLT)jarg11;
4903 plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
4904 {
4905 jdouble **adat;
4906 jobject *ai;
4907 PLFLT **ptr;
4908 int i, j;
4909 int nx = ( *jenv )->GetArrayLength( jenv, jarg9 );
4910 int ny = -1;
4911
4912 ptr = arg9;
4913
4914 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
4915 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
4916
4917 for ( i = 0; i < nx; i++ )
4918 {
4919 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg9, i );
4920 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
4921
4922 if ( ny == -1 )
4923 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
4924 }
4925 for ( i = 0; i < nx; i++ )
4926 {
4927 for ( j = 0; j < ny; j++ )
4928 {
4929 adat[i][j] = ptr[i][j];
4930 }
4931 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
4932 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
4933 }
4934
4935 free( adat );
4936 free( ai );
4937 }
4938 {
4939 free( arg1 );
4940 }
4941 {
4942 free( arg2 );
4943 }
4944 {
4945 free( arg3 );
4946 }
4947 {
4948 free( arg5 );
4949 }
4950 {
4951 free( arg7 );
4952 }
4953 {
4954 free( arg9[0] );
4955 free( arg9 );
4956 }
4957 }
4958
4959
4960 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgspa(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jdoubleArray jarg3, jdoubleArray jarg4) {
4961 PLFLT *arg1 = (PLFLT *) 0 ;
4962 PLFLT *arg2 = (PLFLT *) 0 ;
4963 PLFLT *arg3 = (PLFLT *) 0 ;
4964 PLFLT *arg4 = (PLFLT *) 0 ;
4965 PLFLT temp1 ;
4966 PLFLT temp2 ;
4967 PLFLT temp3 ;
4968 PLFLT temp4 ;
4969
4970 (void)jenv;
4971 (void)jcls;
4972 {
4973 if (!jarg1) {
4974 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4975 return ;
4976 }
4977 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
4978 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4979 return ;
4980 }
4981 temp1 = (PLFLT)0;
4982 arg1 = &temp1;
4983 }
4984 {
4985 if (!jarg2) {
4986 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4987 return ;
4988 }
4989 if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
4990 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4991 return ;
4992 }
4993 temp2 = (PLFLT)0;
4994 arg2 = &temp2;
4995 }
4996 {
4997 if (!jarg3) {
4998 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4999 return ;
5000 }
5001 if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
5002 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5003 return ;
5004 }
5005 temp3 = (PLFLT)0;
5006 arg3 = &temp3;
5007 }
5008 {
5009 if (!jarg4) {
5010 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
5011 return ;
5012 }
5013 if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
5014 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5015 return ;
5016 }
5017 temp4 = (PLFLT)0;
5018 arg4 = &temp4;
5019 }
5020 plgspa(arg1,arg2,arg3,arg4);
5021 {
5022 jdouble jvalue = (jdouble)temp1;
5023 (*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);
5024 }
5025 {
5026 jdouble jvalue = (jdouble)temp2;
5027 (*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);
5028 }
5029 {
5030 jdouble jvalue = (jdouble)temp3;
5031 (*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);
5032 }
5033 {
5034 jdouble jvalue = (jdouble)temp4;
5035 (*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);
5036 }
5037
5038
5039
5040
5041 }
5042
5043
5044 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgstrm(JNIEnv *jenv, jclass jcls, jintArray jarg1) {
5045 PLINT *arg1 = (PLINT *) 0 ;
5046 PLINT temp1 ;
5047
5048 (void)jenv;
5049 (void)jcls;
5050 {
5051 if (!jarg1) {
5052 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
5053 return ;
5054 }
5055 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
5056 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5057 return ;
5058 }
5059 temp1 = (PLINT)0;
5060 arg1 = &temp1;
5061 }
5062 plgstrm(arg1);
5063 {
5064 jint jvalue = (jint)temp1;
5065 (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
5066 }
5067
5068 }
5069
5070
5071 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgver(JNIEnv *jenv, jclass jcls, jobject jarg1) {
5072 char *arg1 = (char *) 0 ;
5073
5074 (void)jenv;
5075 (void)jcls;
5076 {
5077 arg1 = NULL;
5078 if ( jarg1 != NULL )
5079 {
5080 // Get the String from the StringBuffer
5081 jmethodID setLengthID;
5082 jclass sbufClass = ( *jenv )->GetObjectClass( jenv, jarg1 );
5083 // Take a copy of the C string as the typemap is for a non const C string
5084 jmethodID capacityID = ( *jenv )->GetMethodID( jenv, sbufClass, "capacity", "()I" );
5085 jint capacity = ( *jenv )->CallIntMethod( jenv, jarg1, capacityID );
5086 arg1 = (char *) malloc( (size_t) ( capacity + 1 ) );
5087
5088 // Zero the original StringBuffer, so we can replace it with the result
5089 setLengthID = ( *jenv )->GetMethodID( jenv, sbufClass, "setLength", "(I)V" );
5090 ( *jenv )->CallVoidMethod( jenv, jarg1, setLengthID, (jint) 0 );
5091 }
5092 }
5093 plgver(arg1);
5094 {
5095 if ( arg1 != NULL )
5096 {
5097 // Append the result to the empty StringBuffer
5098 jstring newString = ( *jenv )->NewStringUTF( jenv, arg1 );
5099 jclass sbufClass = ( *jenv )->GetObjectClass( jenv, jarg1 );
5100 jmethodID appendStringID = ( *jenv )->GetMethodID( jenv, sbufClass, "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;" );
5101 ( *jenv )->CallObjectMethod( jenv, jarg1, appendStringID, newString );
5102
5103 // Clean up the string object, no longer needed
5104 free( arg1 );
5105 arg1 = NULL;
5106 }
5107 }
5108
5109 }
5110
5111
5112 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgvpd(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jdoubleArray jarg3, jdoubleArray jarg4) {
5113 PLFLT *arg1 = (PLFLT *) 0 ;
5114 PLFLT *arg2 = (PLFLT *) 0 ;
5115 PLFLT *arg3 = (PLFLT *) 0 ;
5116 PLFLT *arg4 = (PLFLT *) 0 ;
5117 PLFLT temp1 ;
5118 PLFLT temp2 ;
5119 PLFLT temp3 ;
5120 PLFLT temp4 ;
5121
5122 (void)jenv;
5123 (void)jcls;
5124 {
5125 if (!jarg1) {
5126 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
5127 return ;
5128 }
5129 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
5130 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5131 return ;
5132 }
5133 temp1 = (PLFLT)0;
5134 arg1 = &temp1;
5135 }
5136 {
5137 if (!jarg2) {
5138 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
5139 return ;
5140 }
5141 if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
5142 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5143 return ;
5144 }
5145 temp2 = (PLFLT)0;
5146 arg2 = &temp2;
5147 }
5148 {
5149 if (!jarg3) {
5150 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
5151 return ;
5152 }
5153 if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
5154 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5155 return ;
5156 }
5157 temp3 = (PLFLT)0;
5158 arg3 = &temp3;
5159 }
5160 {
5161 if (!jarg4) {
5162 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
5163 return ;
5164 }
5165 if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
5166 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5167 return ;
5168 }
5169 temp4 = (PLFLT)0;
5170 arg4 = &temp4;
5171 }
5172 plgvpd(arg1,arg2,arg3,arg4);
5173 {
5174 jdouble jvalue = (jdouble)temp1;
5175 (*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);
5176 }
5177 {
5178 jdouble jvalue = (jdouble)temp2;
5179 (*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);
5180 }
5181 {
5182 jdouble jvalue = (jdouble)temp3;
5183 (*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);
5184 }
5185 {
5186 jdouble jvalue = (jdouble)temp4;
5187 (*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);
5188 }
5189
5190
5191
5192
5193 }
5194
5195
5196 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgvpw(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jdoubleArray jarg3, jdoubleArray jarg4) {
5197 PLFLT *arg1 = (PLFLT *) 0 ;
5198 PLFLT *arg2 = (PLFLT *) 0 ;
5199 PLFLT *arg3 = (PLFLT *) 0 ;
5200 PLFLT *arg4 = (PLFLT *) 0 ;
5201 PLFLT temp1 ;
5202 PLFLT temp2 ;
5203 PLFLT temp3 ;
5204 PLFLT temp4 ;
5205
5206 (void)jenv;
5207 (void)jcls;
5208 {
5209 if (!jarg1) {
5210 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
5211 return ;
5212 }
5213 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
5214 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5215 return ;
5216 }
5217 temp1 = (PLFLT)0;
5218 arg1 = &temp1;
5219 }
5220 {
5221 if (!jarg2) {
5222 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
5223 return ;
5224 }
5225 if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
5226 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5227 return ;
5228 }
5229 temp2 = (PLFLT)0;
5230 arg2 = &temp2;
5231 }
5232 {
5233 if (!jarg3) {
5234 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
5235 return ;
5236 }
5237 if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {
5238 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5239 return ;
5240 }
5241 temp3 = (PLFLT)0;
5242 arg3 = &temp3;
5243 }
5244 {
5245 if (!jarg4) {
5246 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
5247 return ;
5248 }
5249 if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
5250 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5251 return ;
5252 }
5253 temp4 = (PLFLT)0;
5254 arg4 = &temp4;
5255 }
5256 plgvpw(arg1,arg2,arg3,arg4);
5257 {
5258 jdouble jvalue = (jdouble)temp1;
5259 (*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);
5260 }
5261 {
5262 jdouble jvalue = (jdouble)temp2;
5263 (*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);
5264 }
5265 {
5266 jdouble jvalue = (jdouble)temp3;
5267 (*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);
5268 }
5269 {
5270 jdouble jvalue = (jdouble)temp4;
5271 (*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);
5272 }
5273
5274
5275
5276
5277 }
5278
5279
5280 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgxax(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2) {
5281 PLINT *arg1 = (PLINT *) 0 ;
5282 PLINT *arg2 = (PLINT *) 0 ;
5283 PLINT temp1 ;
5284 PLINT temp2 ;
5285
5286 (void)jenv;
5287 (void)jcls;
5288 {
5289 if (!jarg1) {
5290 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
5291 return ;
5292 }
5293 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
5294 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5295 return ;
5296 }
5297 temp1 = (PLINT)0;
5298 arg1 = &temp1;
5299 }
5300 {
5301 if (!jarg2) {
5302 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
5303 return ;
5304 }
5305 if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
5306 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5307 return ;
5308 }
5309 temp2 = (PLINT)0;
5310 arg2 = &temp2;
5311 }
5312 plgxax(arg1,arg2);
5313 {
5314 jint jvalue = (jint)temp1;
5315 (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
5316 }
5317 {
5318 jint jvalue = (jint)temp2;
5319 (*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);
5320 }
5321
5322
5323 }
5324
5325
5326 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgyax(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2) {
5327 PLINT *arg1 = (PLINT *) 0 ;
5328 PLINT *arg2 = (PLINT *) 0 ;
5329 PLINT temp1 ;
5330 PLINT temp2 ;
5331
5332 (void)jenv;
5333 (void)jcls;
5334 {
5335 if (!jarg1) {
5336 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
5337 return ;
5338 }
5339 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
5340 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5341 return ;
5342 }
5343 temp1 = (PLINT)0;
5344 arg1 = &temp1;
5345 }
5346 {
5347 if (!jarg2) {
5348 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
5349 return ;
5350 }
5351 if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
5352 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5353 return ;
5354 }
5355 temp2 = (PLINT)0;
5356 arg2 = &temp2;
5357 }
5358 plgyax(arg1,arg2);
5359 {
5360 jint jvalue = (jint)temp1;
5361 (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
5362 }
5363 {
5364 jint jvalue = (jint)temp2;
5365 (*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);
5366 }
5367
5368
5369 }
5370
5371
5372 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgzax(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2) {
5373 PLINT *arg1 = (PLINT *) 0 ;
5374 PLINT *arg2 = (PLINT *) 0 ;
5375 PLINT temp1 ;
5376 PLINT temp2 ;
5377
5378 (void)jenv;
5379 (void)jcls;
5380 {
5381 if (!jarg1) {
5382 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
5383 return ;
5384 }
5385 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
5386 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5387 return ;
5388 }
5389 temp1 = (PLINT)0;
5390 arg1 = &temp1;
5391 }
5392 {
5393 if (!jarg2) {
5394 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
5395 return ;
5396 }
5397 if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
5398 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5399 return ;
5400 }
5401 temp2 = (PLINT)0;
5402 arg2 = &temp2;
5403 }
5404 plgzax(arg1,arg2);
5405 {
5406 jint jvalue = (jint)temp1;
5407 (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
5408 }
5409 {
5410 jint jvalue = (jint)temp2;
5411 (*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);
5412 }
5413
5414
5415 }
5416
5417
5418 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plhist(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdouble jarg3, jdouble jarg4, jint jarg5, jint jarg6) {
5419 PLINT arg1 ;
5420 PLFLT *arg2 = (PLFLT *) 0 ;
5421 PLFLT arg3 ;
5422 PLFLT arg4 ;
5423 PLINT arg5 ;
5424 PLINT arg6 ;
5425
5426 (void)jenv;
5427 (void)jcls;
5428 {
5429 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
5430 arg1 = ( *jenv )->GetArrayLength( jenv, jarg1 );
5431 Alen = arg1;
5432 setup_array_1d_d( &arg2, jxdata, Alen );
5433 // Could find no easy way to do this as part of freearg so I modified
5434 // the previous function so it ALWAYS mallocs and copies so that
5435 // the java array can be released immediately.
5436 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
5437 }
5438 arg3 = (PLFLT)jarg3;
5439 arg4 = (PLFLT)jarg4;
5440 arg5 = (PLINT)jarg5;
5441 arg6 = (PLINT)jarg6;
5442 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
5443 {
5444 free( arg2 );
5445 }
5446 }
5447
5448
5449 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plhlsrgb(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdoubleArray jarg4, jdoubleArray jarg5, jdoubleArray jarg6) {
5450 PLFLT arg1 ;
5451 PLFLT arg2 ;
5452 PLFLT arg3 ;
5453 PLFLT *arg4 = (PLFLT *) 0 ;
5454 PLFLT *arg5 = (PLFLT *) 0 ;
5455 PLFLT *arg6 = (PLFLT *) 0 ;
5456 PLFLT temp4 ;
5457 PLFLT temp5 ;
5458 PLFLT temp6 ;
5459
5460 (void)jenv;
5461 (void)jcls;
5462 arg1 = (PLFLT)jarg1;
5463 arg2 = (PLFLT)jarg2;
5464 arg3 = (PLFLT)jarg3;
5465 {
5466 if (!jarg4) {
5467 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
5468 return ;
5469 }
5470 if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
5471 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5472 return ;
5473 }
5474 temp4 = (PLFLT)0;
5475 arg4 = &temp4;
5476 }
5477 {
5478 if (!jarg5) {
5479 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
5480 return ;
5481 }
5482 if ((*jenv)->GetArrayLength(jenv, jarg5) == 0) {
5483 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5484 return ;
5485 }
5486 temp5 = (PLFLT)0;
5487 arg5 = &temp5;
5488 }
5489 {
5490 if (!jarg6) {
5491 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
5492 return ;
5493 }
5494 if ((*jenv)->GetArrayLength(jenv, jarg6) == 0) {
5495 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5496 return ;
5497 }
5498 temp6 = (PLFLT)0;
5499 arg6 = &temp6;
5500 }
5501 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
5502 {
5503 jdouble jvalue = (jdouble)temp4;
5504 (*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);
5505 }
5506 {
5507 jdouble jvalue = (jdouble)temp5;
5508 (*jenv)->SetDoubleArrayRegion(jenv, jarg5, 0, 1, &jvalue);
5509 }
5510 {
5511 jdouble jvalue = (jdouble)temp6;
5512 (*jenv)->SetDoubleArrayRegion(jenv, jarg6, 0, 1, &jvalue);
5513 }
5514
5515
5516
5517 }
5518
5519
5520 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plinit(JNIEnv *jenv, jclass jcls) {
5521 (void)jenv;
5522 (void)jcls;
5523 plinit();
5524 }
5525
5526
5527 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pljoin(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4) {
5528 PLFLT arg1 ;
5529 PLFLT arg2 ;
5530 PLFLT arg3 ;
5531 PLFLT arg4 ;
5532
5533 (void)jenv;
5534 (void)jcls;
5535 arg1 = (PLFLT)jarg1;
5536 arg2 = (PLFLT)jarg2;
5537 arg3 = (PLFLT)jarg3;
5538 arg4 = (PLFLT)jarg4;
5539 pljoin(arg1,arg2,arg3,arg4);
5540 }
5541
5542
5543 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pllab(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2, jstring jarg3) {
5544 char *arg1 = (char *) 0 ;
5545 char *arg2 = (char *) 0 ;
5546 char *arg3 = (char *) 0 ;
5547
5548 (void)jenv;
5549 (void)jcls;
5550 arg1 = 0;
5551 if (jarg1) {
5552 arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
5553 if (!arg1) return ;
5554 }
5555 arg2 = 0;
5556 if (jarg2) {
5557 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);
5558 if (!arg2) return ;
5559 }
5560 arg3 = 0;
5561 if (jarg3) {
5562 arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0);
5563 if (!arg3) return ;
5564 }
5565 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
5566 if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
5567 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2);
5568 if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3);
5569 }
5570
5571
5572 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, jdoubleArray jarg24, jintArray jarg25, jintArray jarg26, jdoubleArray jarg27, jintArray jarg28, jdoubleArray jarg29, jintArray jarg30, jobjectArray jarg31) {
5573 PLFLT *arg1 = (PLFLT *) 0 ;
5574 PLFLT *arg2 = (PLFLT *) 0 ;
5575 PLINT arg3 ;
5576 PLINT arg4 ;
5577 PLFLT arg5 ;
5578 PLFLT arg6 ;
5579 PLFLT arg7 ;
5580 PLINT arg8 ;
5581 PLINT arg9 ;
5582 PLINT arg10 ;
5583 PLINT arg11 ;
5584 PLINT arg12 ;
5585 PLINT arg13 ;
5586 PLINT *arg14 = (PLINT *) 0 ;
5587 PLFLT arg15 ;
5588 PLFLT arg16 ;
5589 PLFLT arg17 ;
5590 PLFLT arg18 ;
5591 PLINT *arg19 = (PLINT *) 0 ;
5592 char **arg20 = (char **) 0 ;
5593 PLINT *arg21 = (PLINT *) 0 ;
5594 PLINT *arg22 = (PLINT *) 0 ;
5595 PLFLT *arg23 = (PLFLT *) 0 ;
5596 PLFLT *arg24 = (PLFLT *) 0 ;
5597 PLINT *arg25 = (PLINT *) 0 ;
5598 PLINT *arg26 = (PLINT *) 0 ;
5599 PLFLT *arg27 = (PLFLT *) 0 ;
5600 PLINT *arg28 = (PLINT *) 0 ;
5601 PLFLT *arg29 = (PLFLT *) 0 ;
5602 PLINT *arg30 = (PLINT *) 0 ;
5603 char **arg31 = (char **) 0 ;
5604 PLFLT temp1 ;
5605 PLFLT temp2 ;
5606
5607 (void)jenv;
5608 (void)jcls;
5609 {
5610 if (!jarg1) {
5611 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
5612 return ;
5613 }
5614 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
5615 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5616 return ;
5617 }
5618 temp1 = (PLFLT)0;
5619 arg1 = &temp1;
5620 }
5621 {
5622 if (!jarg2) {
5623 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
5624 return ;
5625 }
5626 if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
5627 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5628 return ;
5629 }
5630 temp2 = (PLFLT)0;
5631 arg2 = &temp2;
5632 }
5633 arg3 = (PLINT)jarg3;
5634 arg4 = (PLINT)jarg4;
5635 arg5 = (PLFLT)jarg5;
5636 arg6 = (PLFLT)jarg6;
5637 arg7 = (PLFLT)jarg7;
5638 arg8 = (PLINT)jarg8;
5639 arg9 = (PLINT)jarg9;
5640 arg10 = (PLINT)jarg10;
5641 arg11 = (PLINT)jarg11;
5642 arg12 = (PLINT)jarg12;
5643 {
5644 jint *jxdata = ( *jenv )->GetIntArrayElements( jenv, jarg13, 0 );
5645 arg13 = ( *jenv )->GetArrayLength( jenv, jarg13 );
5646 Alen = arg13;
5647 setup_array_1d_i( &arg14, jxdata, Alen );
5648 // Could find no easy way to do this as part of freearg so I modified
5649 // the previous function so it ALWAYS mallocs and copies so that
5650 // the java array can be released immediately.
5651 ( *jenv )->ReleaseIntArrayElements( jenv, jarg13, jxdata, 0 );
5652 }
5653 arg15 = (PLFLT)jarg15;
5654 arg16 = (PLFLT)jarg16;
5655 arg17 = (PLFLT)jarg17;
5656 arg18 = (PLFLT)jarg18;
5657 {
5658 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg19, 0 );
5659 if ( ( *jenv )->GetArrayLength( jenv, jarg19 ) != Alen )
5660 {
5661 printf( "Vectors must be same length.\n" );
5662 return;
5663 }
5664 setup_array_1d_i( &arg19, jydata, Alen );
5665 ( *jenv )->ReleaseIntArrayElements( jenv, jarg19, jydata, 0 );
5666 }
5667 {
5668 int i = 0;
5669 if ( jarg20 != NULL )
5670 {
5671 int size = ( *jenv )->GetArrayLength( jenv, jarg20 );
5672 if ( size != Alen )
5673 {
5674 printf( "Arrays must be the same length\n" );
5675 return;
5676 }
5677 arg20 = (char **) malloc( (size_t) Alen * sizeof ( char * ) );
5678 // make a copy of each string
5679 for ( i = 0; i < Alen; i++ )
5680 {
5681 jstring j_string = (jstring) ( *jenv )->GetObjectArrayElement( jenv, jarg20, i );
5682 const char * c_string = (char *) ( *jenv )->GetStringUTFChars( jenv, j_string, 0 );
5683 arg20[i] = malloc( ( strlen( c_string ) + 1 ) * sizeof ( const char * ) );
5684 strcpy( arg20[i], c_string );
5685 ( *jenv )->ReleaseStringUTFChars( jenv, j_string, c_string );
5686 ( *jenv )->DeleteLocalRef( jenv, j_string );
5687 }
5688 }
5689 else
5690 {
5691 arg20 = NULL;
5692 }
5693 }
5694 {
5695 if ( jarg21 != NULL )
5696 {
5697 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg21, 0 );
5698 if ( ( *jenv )->GetArrayLength( jenv, jarg21 ) != Alen )
5699 {
5700 printf( "Vectors must be same length.\n" );
5701 return;
5702 }
5703 setup_array_1d_i( &arg21, jydata, Alen );
5704 ( *jenv )->ReleaseIntArrayElements( jenv, jarg21, jydata, 0 );
5705 }
5706 else
5707 {
5708 arg21 = NULL;
5709 }
5710 }
5711 {
5712 if ( jarg22 != NULL )
5713 {
5714 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg22, 0 );
5715 if ( ( *jenv )->GetArrayLength( jenv, jarg22 ) != Alen )
5716 {
5717 printf( "Vectors must be same length.\n" );
5718 return;
5719 }
5720 setup_array_1d_i( &arg22, jydata, Alen );
5721 ( *jenv )->ReleaseIntArrayElements( jenv, jarg22, jydata, 0 );
5722 }
5723 else
5724 {
5725 arg22 = NULL;
5726 }
5727 }
5728 {
5729 if ( jarg23 != NULL )
5730 {
5731 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg23, 0 );
5732 if ( ( *jenv )->GetArrayLength( jenv, jarg23 ) != Alen )
5733 {
5734 printf( "Vectors must be same length.\n" );
5735 return;
5736 }
5737 setup_array_1d_d( &arg23, jydata, Alen );
5738 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg23, jydata, 0 );
5739 }
5740 else
5741 {
5742 arg23 = NULL;
5743 }
5744 }
5745 {
5746 if ( jarg24 != NULL )
5747 {
5748 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg24, 0 );
5749 if ( ( *jenv )->GetArrayLength( jenv, jarg24 ) != Alen )
5750 {
5751 printf( "Vectors must be same length.\n" );
5752 return;
5753 }
5754 setup_array_1d_d( &arg24, jydata, Alen );
5755 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg24, jydata, 0 );
5756 }
5757 else
5758 {
5759 arg24 = NULL;
5760 }
5761 }
5762 {
5763 if ( jarg25 != NULL )
5764 {
5765 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg25, 0 );
5766 if ( ( *jenv )->GetArrayLength( jenv, jarg25 ) != Alen )
5767 {
5768 printf( "Vectors must be same length.\n" );
5769 return;
5770 }
5771 setup_array_1d_i( &arg25, jydata, Alen );
5772 ( *jenv )->ReleaseIntArrayElements( jenv, jarg25, jydata, 0 );
5773 }
5774 else
5775 {
5776 arg25 = NULL;
5777 }
5778 }
5779 {
5780 if ( jarg26 != NULL )
5781 {
5782 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg26, 0 );
5783 if ( ( *jenv )->GetArrayLength( jenv, jarg26 ) != Alen )
5784 {
5785 printf( "Vectors must be same length.\n" );
5786 return;
5787 }
5788 setup_array_1d_i( &arg26, jydata, Alen );
5789 ( *jenv )->ReleaseIntArrayElements( jenv, jarg26, jydata, 0 );
5790 }
5791 else
5792 {
5793 arg26 = NULL;
5794 }
5795 }
5796 {
5797 if ( jarg27 != NULL )
5798 {
5799 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg27, 0 );
5800 if ( ( *jenv )->GetArrayLength( jenv, jarg27 ) != Alen )
5801 {
5802 printf( "Vectors must be same length.\n" );
5803 return;
5804 }
5805 setup_array_1d_d( &arg27, jydata, Alen );
5806 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg27, jydata, 0 );
5807 }
5808 else
5809 {
5810 arg27 = NULL;
5811 }
5812 }
5813 {
5814 if ( jarg28 != NULL )
5815 {
5816 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg28, 0 );
5817 if ( ( *jenv )->GetArrayLength( jenv, jarg28 ) != Alen )
5818 {
5819 printf( "Vectors must be same length.\n" );
5820 return;
5821 }
5822 setup_array_1d_i( &arg28, jydata, Alen );
5823 ( *jenv )->ReleaseIntArrayElements( jenv, jarg28, jydata, 0 );
5824 }
5825 else
5826 {
5827 arg28 = NULL;
5828 }
5829 }
5830 {
5831 if ( jarg29 != NULL )
5832 {
5833 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg29, 0 );
5834 if ( ( *jenv )->GetArrayLength( jenv, jarg29 ) != Alen )
5835 {
5836 printf( "Vectors must be same length.\n" );
5837 return;
5838 }
5839 setup_array_1d_d( &arg29, jydata, Alen );
5840 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg29, jydata, 0 );
5841 }
5842 else
5843 {
5844 arg29 = NULL;
5845 }
5846 }
5847 {
5848 if ( jarg30 != NULL )
5849 {
5850 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg30, 0 );
5851 if ( ( *jenv )->GetArrayLength( jenv, jarg30 ) != Alen )
5852 {
5853 printf( "Vectors must be same length.\n" );
5854 return;
5855 }
5856 setup_array_1d_i( &arg30, jydata, Alen );
5857 ( *jenv )->ReleaseIntArrayElements( jenv, jarg30, jydata, 0 );
5858 }
5859 else
5860 {
5861 arg30 = NULL;
5862 }
5863 }
5864 {
5865 int i = 0;
5866 if ( jarg31 != NULL )
5867 {
5868 int size = ( *jenv )->GetArrayLength( jenv, jarg31 );
5869 if ( size != Alen )
5870 {
5871 printf( "Arrays must be the same length\n" );
5872 return;
5873 }
5874 arg31 = (char **) malloc( (size_t) Alen * sizeof ( char * ) );
5875 // make a copy of each string
5876 for ( i = 0; i < Alen; i++ )
5877 {
5878 jstring j_string = (jstring) ( *jenv )->GetObjectArrayElement( jenv, jarg31, i );
5879 const char * c_string = (char *) ( *jenv )->GetStringUTFChars( jenv, j_string, 0 );
5880 arg31[i] = malloc( ( strlen( c_string ) + 1 ) * sizeof ( const char * ) );
5881 strcpy( arg31[i], c_string );
5882 ( *jenv )->ReleaseStringUTFChars( jenv, j_string, c_string );
5883 ( *jenv )->DeleteLocalRef( jenv, j_string );
5884 }
5885 }
5886 else
5887 {
5888 arg31 = NULL;
5889 }
5890 }
5891 pllegend(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(int const *)arg14,arg15,arg16,arg17,arg18,(int const *)arg19,(char const **)arg20,(int const *)arg21,(int const *)arg22,(double const *)arg23,(double const *)arg24,(int const *)arg25,(int const *)arg26,(double const *)arg27,(int const *)arg28,(double const *)arg29,(int const *)arg30,(char const **)arg31);
5892 {
5893 jdouble jvalue = (jdouble)temp1;
5894 (*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);
5895 }
5896 {
5897 jdouble jvalue = (jdouble)temp2;
5898 (*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);
5899 }
5900
5901
5902 {
5903 free( arg14 );
5904 }
5905 {
5906 free( arg19 );
5907 }
5908 {
5909 int i;
5910 if ( arg20 != NULL )
5911 {
5912 for ( i = 0; i < Alen; i++ )
5913 free( arg20[i] );
5914 free( arg20 );
5915 }
5916 }
5917 {
5918 if ( arg21 != NULL )
5919 free( arg21 );
5920 }
5921 {
5922 if ( arg22 != NULL )
5923 free( arg22 );
5924 }
5925 {
5926 if ( arg23 != NULL )
5927 free( arg23 );
5928 }
5929 {
5930 if ( arg24 != NULL )
5931 free( arg24 );
5932 }
5933 {
5934 if ( arg25 != NULL )
5935 free( arg25 );
5936 }
5937 {
5938 if ( arg26 != NULL )
5939 free( arg26 );
5940 }
5941 {
5942 if ( arg27 != NULL )
5943 free( arg27 );
5944 }
5945 {
5946 if ( arg28 != NULL )
5947 free( arg28 );
5948 }
5949 {
5950 if ( arg29 != NULL )
5951 free( arg29 );
5952 }
5953 {
5954 if ( arg30 != NULL )
5955 free( arg30 );
5956 }
5957 {
5958 int i;
5959 if ( arg31 != NULL )
5960 {
5961 for ( i = 0; i < Alen; i++ )
5962 free( arg31[i] );
5963 free( arg31 );
5964 }
5965 }
5966 }
5967
5968
5969 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plcolorbar(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jint jarg3, jint jarg4, jdouble jarg5, jdouble jarg6, jdouble jarg7, jdouble jarg8, jint jarg9, jint jarg10, jint jarg11, jdouble jarg12, jdouble jarg13, jint jarg14, jdouble jarg15, jintArray jarg16, jobjectArray jarg18, jobjectArray jarg19, jdoubleArray jarg21, jintArray jarg22, jintArray jarg23, jobjectArray jarg24) {
5970 PLFLT *arg1 = (PLFLT *) 0 ;
5971 PLFLT *arg2 = (PLFLT *) 0 ;
5972 PLINT arg3 ;
5973 PLINT arg4 ;
5974 PLFLT arg5 ;
5975 PLFLT arg6 ;
5976 PLFLT arg7 ;
5977 PLFLT arg8 ;
5978 PLINT arg9 ;
5979 PLINT arg10 ;
5980 PLINT arg11 ;
5981 PLFLT arg12 ;
5982 PLFLT arg13 ;
5983 PLINT arg14 ;
5984 PLFLT arg15 ;
5985 PLINT arg16 ;
5986 PLINT *arg17 = (PLINT *) 0 ;
5987 char **arg18 = (char **) 0 ;
5988 PLINT arg19 ;
5989 char **arg20 = (char **) 0 ;
5990 PLFLT *arg21 = (PLFLT *) 0 ;
5991 PLINT *arg22 = (PLINT *) 0 ;
5992 PLINT *arg23 = (PLINT *) 0 ;
5993 PLFLT **arg24 = (PLFLT **) 0 ;
5994 PLFLT temp1 ;
5995 PLFLT temp2 ;
5996
5997 (void)jenv;
5998 (void)jcls;
5999 {
6000 if (!jarg1) {
6001 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
6002 return ;
6003 }
6004 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
6005 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
6006 return ;
6007 }
6008 temp1 = (PLFLT)0;
6009 arg1 = &temp1;
6010 }
6011 {
6012 if (!jarg2) {
6013 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
6014 return ;
6015 }
6016 if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
6017 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
6018 return ;
6019 }
6020 temp2 = (PLFLT)0;
6021 arg2 = &temp2;
6022 }
6023 arg3 = (PLINT)jarg3;
6024 arg4 = (PLINT)jarg4;
6025 arg5 = (PLFLT)jarg5;
6026 arg6 = (PLFLT)jarg6;
6027 arg7 = (PLFLT)jarg7;
6028 arg8 = (PLFLT)jarg8;
6029 arg9 = (PLINT)jarg9;
6030 arg10 = (PLINT)jarg10;
6031 arg11 = (PLINT)jarg11;
6032 arg12 = (PLFLT)jarg12;
6033 arg13 = (PLFLT)jarg13;
6034 arg14 = (PLINT)jarg14;
6035 arg15 = (PLFLT)jarg15;
6036 {
6037 jint *jxdata = ( *jenv )->GetIntArrayElements( jenv, jarg16, 0 );
6038 arg16 = ( *jenv )->GetArrayLength( jenv, jarg16 );
6039 Alen = arg16;
6040 setup_array_1d_i( &arg17, jxdata, Alen );
6041 // Could find no easy way to do this as part of freearg so I modified
6042 // the previous function so it ALWAYS mallocs and copies so that
6043 // the java array can be released immediately.
6044 ( *jenv )->ReleaseIntArrayElements( jenv, jarg16, jxdata, 0 );
6045 }
6046 {
6047 int i = 0;
6048 if ( jarg18 != NULL )
6049 {
6050 int size = ( *jenv )->GetArrayLength( jenv, jarg18 );
6051 if ( size != Alen )
6052 {
6053 printf( "Arrays must be the same length\n" );
6054 return;
6055 }
6056 arg18 = (char **) malloc( (size_t) Alen * sizeof ( char * ) );
6057 // make a copy of each string
6058 for ( i = 0; i < Alen; i++ )
6059 {
6060 jstring j_string = (jstring) ( *jenv )->GetObjectArrayElement( jenv, jarg18, i );
6061 const char * c_string = (char *) ( *jenv )->GetStringUTFChars( jenv, j_string, 0 );
6062 arg18[i] = malloc( ( strlen( c_string ) + 1 ) * sizeof ( const char * ) );
6063 strcpy( arg18[i], c_string );
6064 ( *jenv )->ReleaseStringUTFChars( jenv, j_string, c_string );
6065 ( *jenv )->DeleteLocalRef( jenv, j_string );
6066 }
6067 }
6068 else
6069 {
6070 arg18 = NULL;
6071 }
6072 }
6073 {
6074 int i = 0;
6075 if ( jarg19 != NULL )
6076 {
6077 int size = ( *jenv )->GetArrayLength( jenv, jarg19 );
6078 Alen = size;
6079 arg19 = size;
6080 arg20 = (char **) malloc( (size_t) Alen * sizeof ( char * ) );
6081 // make a copy of each string
6082 for ( i = 0; i < Alen; i++ )
6083 {
6084 jstring j_string = (jstring) ( *jenv )->GetObjectArrayElement( jenv, jarg19, i );
6085 const char * c_string = (char *) ( *jenv )->GetStringUTFChars( jenv, j_string, 0 );
6086 arg20[i] = malloc( ( strlen( c_string ) + 1 ) * sizeof ( const char * ) );
6087 strcpy( arg20[i], c_string );
6088 ( *jenv )->ReleaseStringUTFChars( jenv, j_string, c_string );
6089 ( *jenv )->DeleteLocalRef( jenv, j_string );
6090 }
6091 }
6092 else
6093 {
6094 arg19 = 0;
6095 arg20 = NULL;
6096 }
6097 }
6098 {
6099 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg21, 0 );
6100 if ( ( *jenv )->GetArrayLength( jenv, jarg21 ) != Alen )
6101 {
6102 printf( "Vectors must be same length.\n" );
6103 return;
6104 }
6105 setup_array_1d_d( &arg21, jydata, Alen );
6106 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg21, jydata, 0 );
6107 }
6108 {
6109 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg22, 0 );
6110 if ( ( *jenv )->GetArrayLength( jenv, jarg22 ) != Alen )
6111 {
6112 printf( "Vectors must be same length.\n" );
6113 return;
6114 }
6115 setup_array_1d_i( &arg22, jydata, Alen );
6116 ( *jenv )->ReleaseIntArrayElements( jenv, jarg22, jydata, 0 );
6117 }
6118 {
6119 int i;
6120 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg23, 0 );
6121 if ( ( *jenv )->GetArrayLength( jenv, jarg23 ) != Alen )
6122 {
6123 printf( "Vectors must be same length.\n" );
6124 return;
6125 }
6126 Xlen = ( *jenv )->GetArrayLength( jenv, jarg23 );
6127 Ylen = -1;
6128 for ( i = 0; i < Xlen; i++ )
6129 if ( jydata[i] > Ylen )
6130 Ylen = jydata[i];
6131 setup_array_1d_i( &arg23, jydata, Alen );
6132 ( *jenv )->ReleaseIntArrayElements( jenv, jarg23, jydata, 0 );
6133 }
6134 {
6135 jdouble **adat;
6136 jobject *ai;
6137 int nx = ( *jenv )->GetArrayLength( jenv, jarg24 );
6138 int ny = -1;
6139 int i, j;
6140 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
6141 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
6142
6143 ( *jenv )->EnsureLocalCapacity( jenv, nx );
6144
6145 for ( i = 0; i < nx; i++ )
6146 {
6147 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg24, i );
6148 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
6149
6150 if ( ny == -1 )
6151 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
6152 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
6153 {
6154 printf( "Misshapen a array.\n" );
6155 for ( j = 0; j <= i; j++ )
6156 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
6157 free( adat );
6158 free( ai );
6159 return;
6160 }
6161 }
6162
6163 if ( nx != Xlen || ny != Ylen )
6164 {
6165 printf( "Vectors must match matrix.\n" );
6166 for ( i = 0; i < nx; i++ )
6167 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
6168 free( adat );
6169 free( ai );
6170 return;
6171 }
6172 setup_array_2d_d( &arg24, adat, nx, ny );
6173 for ( i = 0; i < nx; i++ )
6174 {
6175 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
6176 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
6177 }
6178
6179 free( adat );
6180 free( ai );
6181 }
6182 plcolorbar(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,(int const *)arg17,(char const **)arg18,arg19,(char const **)arg20,(double const *)arg21,(int const *)arg22,(int const *)arg23,(double const **)arg24);
6183 {
6184 jdouble jvalue = (jdouble)temp1;
6185 (*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);
6186 }
6187 {
6188 jdouble jvalue = (jdouble)temp2;
6189 (*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);
6190 }
6191
6192
6193 {
6194 free( arg17 );
6195 }
6196 {
6197 int i;
6198 if ( arg18 != NULL )
6199 {
6200 for ( i = 0; i < Alen; i++ )
6201 free( arg18[i] );
6202 free( arg18 );
6203 }
6204 }
6205 {
6206 int i;
6207 if ( arg20 != NULL )
6208 {
6209 for ( i = 0; i < Alen; i++ )
6210 free( arg20[i] );
6211 free( arg20 );
6212 }
6213 }
6214 {
6215 free( arg21 );
6216 }
6217 {
6218 free( arg22 );
6219 }
6220 {
6221 free( arg23 );
6222 }
6223 {
6224 free( arg24[0] );
6225 free( arg24 );
6226 }
6227 }
6228
6229
6230 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pllightsource(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3) {
6231 PLFLT arg1 ;
6232 PLFLT arg2 ;
6233 PLFLT arg3 ;
6234
6235 (void)jenv;
6236 (void)jcls;
6237 arg1 = (PLFLT)jarg1;
6238 arg2 = (PLFLT)jarg2;
6239 arg3 = (PLFLT)jarg3;
6240 pllightsource(arg1,arg2,arg3);
6241 }
6242
6243
6244 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plline(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3) {
6245 PLINT arg1 ;
6246 PLFLT *arg2 = (PLFLT *) 0 ;
6247 PLFLT *arg3 = (PLFLT *) 0 ;
6248
6249 (void)jenv;
6250 (void)jcls;
6251 {
6252 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
6253 arg1 = ( *jenv )->GetArrayLength( jenv, jarg1 );
6254 Alen = arg1;
6255 setup_array_1d_d( &arg2, jxdata, Alen );
6256 // Could find no easy way to do this as part of freearg so I modified
6257 // the previous function so it ALWAYS mallocs and copies so that
6258 // the java array can be released immediately.
6259 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
6260 }
6261 {
6262 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
6263 if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
6264 {
6265 printf( "Vectors must be same length.\n" );
6266 return;
6267 }
6268 setup_array_1d_d( &arg3, jydata, Alen );
6269 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
6270 }
6271 plline(arg1,(double const *)arg2,(double const *)arg3);
6272 {
6273 free( arg2 );
6274 }
6275 {
6276 free( arg3 );
6277 }
6278 }
6279
6280
6281 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plline3(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jdoubleArray jarg4) {
6282 PLINT arg1 ;
6283 PLFLT *arg2 = (PLFLT *) 0 ;
6284 PLFLT *arg3 = (PLFLT *) 0 ;
6285 PLFLT *arg4 = (PLFLT *) 0 ;
6286
6287 (void)jenv;
6288 (void)jcls;
6289 {
6290 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
6291 arg1 = ( *jenv )->GetArrayLength( jenv, jarg1 );
6292 Alen = arg1;
6293 setup_array_1d_d( &arg2, jxdata, Alen );
6294 // Could find no easy way to do this as part of freearg so I modified
6295 // the previous function so it ALWAYS mallocs and copies so that
6296 // the java array can be released immediately.
6297 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
6298 }
6299 {
6300 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
6301 if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
6302 {
6303 printf( "Vectors must be same length.\n" );
6304 return;
6305 }
6306 setup_array_1d_d( &arg3, jydata, Alen );
6307 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
6308 }
6309 {
6310 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg4, 0 );
6311 if ( ( *jenv )->GetArrayLength( jenv, jarg4 ) != Alen )
6312 {
6313 printf( "Vectors must be same length.\n" );
6314 return;
6315 }
6316 setup_array_1d_d( &arg4, jydata, Alen );
6317 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );
6318 }
6319 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6320 {
6321 free( arg2 );
6322 }
6323 {
6324 free( arg3 );
6325 }
6326 {
6327 free( arg4 );
6328 }
6329 }
6330
6331
6332 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pllsty(JNIEnv *jenv, jclass jcls, jint jarg1) {
6333 PLINT arg1 ;
6334
6335 (void)jenv;
6336 (void)jcls;
6337 arg1 = (PLINT)jarg1;
6338 pllsty(arg1);
6339 }
6340
6341
6342 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plmesh(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jobjectArray jarg3, jint jarg6) {
6343 PLFLT *arg1 = (PLFLT *) 0 ;
6344 PLFLT *arg2 = (PLFLT *) 0 ;
6345 PLFLT **arg3 = (PLFLT **) 0 ;
6346 PLINT arg4 ;
6347 PLINT arg5 ;
6348 PLINT arg6 ;
6349
6350 (void)jenv;
6351 (void)jcls;
6352 {
6353 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
6354 Xlen = ( *jenv )->GetArrayLength( jenv, jarg1 );
6355 setup_array_1d_d( &arg1, jxdata, Xlen );
6356 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
6357 }
6358 {
6359 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg2, 0 );
6360 Ylen = ( *jenv )->GetArrayLength( jenv, jarg2 );
6361 setup_array_1d_d( &arg2, jydata, Ylen );
6362 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );
6363 }
6364 {
6365 jdouble **adat;
6366 jobject *ai;
6367 int nx = ( *jenv )->GetArrayLength( jenv, jarg3 );
6368 int ny = -1;
6369 int i, j;
6370 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
6371 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
6372
6373 ( *jenv )->EnsureLocalCapacity( jenv, nx );
6374
6375 for ( i = 0; i < nx; i++ )
6376 {
6377 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg3, i );
6378 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
6379
6380 if ( ny == -1 )
6381 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
6382 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
6383 {
6384 printf( "Misshapen a array.\n" );
6385 for ( j = 0; j <= i; j++ )
6386 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
6387 free( adat );
6388 free( ai );
6389 return;
6390 }
6391 }
6392
6393 if ( nx != Xlen || ny != Ylen )
6394 {
6395 printf( "Vectors must match matrix.\n" );
6396 for ( i = 0; i < nx; i++ )
6397 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
6398 free( adat );
6399 free( ai );
6400 return;
6401 }
6402 setup_array_2d_d( &arg3, adat, nx, ny );
6403 arg4 = nx;
6404 arg5 = ny;
6405 for ( i = 0; i < nx; i++ )
6406 {
6407 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
6408 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
6409 }
6410
6411
6412 free( adat );
6413 free( ai );
6414 }
6415 arg6 = (PLINT)jarg6;
6416 plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
6417 {
6418 free( arg1 );
6419 }
6420 {
6421 free( arg2 );
6422 }
6423 {
6424 free( arg3[0] );
6425 free( arg3 );
6426 }
6427 }
6428
6429
6430 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plmeshc(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jobjectArray jarg3, jint jarg6, jdoubleArray jarg7) {
6431 PLFLT *arg1 = (PLFLT *) 0 ;
6432 PLFLT *arg2 = (PLFLT *) 0 ;
6433 PLFLT **arg3 = (PLFLT **) 0 ;
6434 PLINT arg4 ;
6435 PLINT arg5 ;
6436 PLINT arg6 ;
6437 PLFLT *arg7 = (PLFLT *) 0 ;
6438 PLINT arg8 ;
6439
6440 (void)jenv;
6441 (void)jcls;
6442 {
6443 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
6444 Xlen = ( *jenv )->GetArrayLength( jenv, jarg1 );
6445 setup_array_1d_d( &arg1, jxdata, Xlen );
6446 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
6447 }
6448 {
6449 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg2, 0 );
6450 Ylen = ( *jenv )->GetArrayLength( jenv, jarg2 );
6451 setup_array_1d_d( &arg2, jydata, Ylen );
6452 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );
6453 }
6454 {
6455 jdouble **adat;
6456 jobject *ai;
6457 int nx = ( *jenv )->GetArrayLength( jenv, jarg3 );
6458 int ny = -1;
6459 int i, j;
6460 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
6461 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
6462
6463 ( *jenv )->EnsureLocalCapacity( jenv, nx );
6464
6465 for ( i = 0; i < nx; i++ )
6466 {
6467 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg3, i );
6468 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
6469
6470 if ( ny == -1 )
6471 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
6472 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
6473 {
6474 printf( "Misshapen a array.\n" );
6475 for ( j = 0; j <= i; j++ )
6476 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
6477 free( adat );
6478 free( ai );
6479 return;
6480 }
6481 }
6482
6483 if ( nx != Xlen || ny != Ylen )
6484 {
6485 printf( "Vectors must match matrix.\n" );
6486 for ( i = 0; i < nx; i++ )
6487 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
6488 free( adat );
6489 free( ai );
6490 return;
6491 }
6492 setup_array_2d_d( &arg3, adat, nx, ny );
6493 arg4 = nx;
6494 arg5 = ny;
6495 for ( i = 0; i < nx; i++ )
6496 {
6497 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
6498 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
6499 }
6500
6501
6502 free( adat );
6503 free( ai );
6504 }
6505 arg6 = (PLINT)jarg6;
6506 {
6507 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg7, 0 );
6508 arg8 = ( *jenv )->GetArrayLength( jenv, jarg7 );
6509 setup_array_1d_d( &arg7, jxdata, arg8 );
6510 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg7, jxdata, 0 );
6511 }
6512 plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
6513 {
6514 free( arg1 );
6515 }
6516 {
6517 free( arg2 );
6518 }
6519 {
6520 free( arg3[0] );
6521 free( arg3 );
6522 }
6523 {
6524 free( arg7 );
6525 }
6526 }
6527
6528
6529 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plmkstrm(JNIEnv *jenv, jclass jcls, jintArray jarg1) {
6530 PLINT *arg1 = (PLINT *) 0 ;
6531 PLINT temp1 ;
6532
6533 (void)jenv;
6534 (void)jcls;
6535 {
6536 if (!jarg1) {
6537 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
6538 return ;
6539 }
6540 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
6541 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
6542 return ;
6543 }
6544 temp1 = (PLINT)0;
6545 arg1 = &temp1;
6546 }
6547 plmkstrm(arg1);
6548 {
6549 jint jvalue = (jint)temp1;
6550 (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
6551 }
6552
6553 }
6554
6555
6556 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plmtex(JNIEnv *jenv, jclass jcls, jstring jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4, jstring jarg5) {
6557 char *arg1 = (char *) 0 ;
6558 PLFLT arg2 ;
6559 PLFLT arg3 ;
6560 PLFLT arg4 ;
6561 char *arg5 = (char *) 0 ;
6562
6563 (void)jenv;
6564 (void)jcls;
6565 arg1 = 0;
6566 if (jarg1) {
6567 arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
6568 if (!arg1) return ;
6569 }
6570 arg2 = (PLFLT)jarg2;
6571 arg3 = (PLFLT)jarg3;
6572 arg4 = (PLFLT)jarg4;
6573 arg5 = 0;
6574 if (jarg5) {
6575 arg5 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg5, 0);
6576 if (!arg5) return ;
6577 }
6578 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
6579 if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
6580 if (arg5) (*jenv)->ReleaseStringUTFChars(jenv, jarg5, (const char *)arg5);
6581 }
6582
6583
6584 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plmtex3(JNIEnv *jenv, jclass jcls, jstring jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4, jstring jarg5) {
6585 char *arg1 = (char *) 0 ;
6586 PLFLT arg2 ;
6587 PLFLT arg3 ;
6588 PLFLT arg4 ;
6589 char *arg5 = (char *) 0 ;
6590
6591 (void)jenv;
6592 (void)jcls;
6593 arg1 = 0;
6594 if (jarg1) {
6595 arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
6596 if (!arg1) return ;
6597 }
6598 arg2 = (PLFLT)jarg2;
6599 arg3 = (PLFLT)jarg3;
6600 arg4 = (PLFLT)jarg4;
6601 arg5 = 0;
6602 if (jarg5) {
6603 arg5 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg5, 0);
6604 if (!arg5) return ;
6605 }
6606 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
6607 if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
6608 if (arg5) (*jenv)->ReleaseStringUTFChars(jenv, jarg5, (const char *)arg5);
6609 }
6610
6611
6612 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plot3d(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jobjectArray jarg3, jint jarg6, jboolean jarg7) {
6613 PLFLT *arg1 = (PLFLT *) 0 ;
6614 PLFLT *arg2 = (PLFLT *) 0 ;
6615 PLFLT **arg3 = (PLFLT **) 0 ;
6616 PLINT arg4 ;
6617 PLINT arg5 ;
6618 PLINT arg6 ;
6619 PLBOOL arg7 ;
6620
6621 (void)jenv;
6622 (void)jcls;
6623 {
6624 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
6625 Xlen = ( *jenv )->GetArrayLength( jenv, jarg1 );
6626 setup_array_1d_d( &arg1, jxdata, Xlen );
6627 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
6628 }
6629 {
6630 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg2, 0 );
6631 Ylen = ( *jenv )->GetArrayLength( jenv, jarg2 );
6632 setup_array_1d_d( &arg2, jydata, Ylen );
6633 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );
6634 }
6635 {
6636 jdouble **adat;
6637 jobject *ai;
6638 int nx = ( *jenv )->GetArrayLength( jenv, jarg3 );
6639 int ny = -1;
6640 int i, j;
6641 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
6642 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
6643
6644 ( *jenv )->EnsureLocalCapacity( jenv, nx );
6645
6646 for ( i = 0; i < nx; i++ )
6647 {
6648 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg3, i );
6649 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
6650
6651 if ( ny == -1 )
6652 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
6653 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
6654 {
6655 printf( "Misshapen a array.\n" );
6656 for ( j = 0; j <= i; j++ )
6657 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
6658 free( adat );
6659 free( ai );
6660 return;
6661 }
6662 }
6663
6664 if ( nx != Xlen || ny != Ylen )
6665 {
6666 printf( "Vectors must match matrix.\n" );
6667 for ( i = 0; i < nx; i++ )
6668 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
6669 free( adat );
6670 free( ai );
6671 return;
6672 }
6673 setup_array_2d_d( &arg3, adat, nx, ny );
6674 arg4 = nx;
6675 arg5 = ny;
6676 for ( i = 0; i < nx; i++ )
6677 {
6678 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
6679 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
6680 }
6681
6682
6683 free( adat );
6684 free( ai );
6685 }
6686 arg6 = (PLINT)jarg6;
6687
6688 arg7 = jarg7 ? 1 : 0;
6689
6690 plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
6691 {
6692 free( arg1 );
6693 }
6694 {
6695 free( arg2 );
6696 }
6697 {
6698 free( arg3[0] );
6699 free( arg3 );
6700 }
6701 }
6702
6703
6704 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plot3dc(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jobjectArray jarg3, jint jarg6, jdoubleArray jarg7) {
6705 PLFLT *arg1 = (PLFLT *) 0 ;
6706 PLFLT *arg2 = (PLFLT *) 0 ;
6707 PLFLT **arg3 = (PLFLT **) 0 ;
6708 PLINT arg4 ;
6709 PLINT arg5 ;
6710 PLINT arg6 ;
6711 PLFLT *arg7 = (PLFLT *) 0 ;
6712 PLINT arg8 ;
6713
6714 (void)jenv;
6715 (void)jcls;
6716 {
6717 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
6718 Xlen = ( *jenv )->GetArrayLength( jenv, jarg1 );
6719 setup_array_1d_d( &arg1, jxdata, Xlen );
6720 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
6721 }
6722 {
6723 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg2, 0 );
6724 Ylen = ( *jenv )->GetArrayLength( jenv, jarg2 );
6725 setup_array_1d_d( &arg2, jydata, Ylen );
6726 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );
6727 }
6728 {
6729 jdouble **adat;
6730 jobject *ai;
6731 int nx = ( *jenv )->GetArrayLength( jenv, jarg3 );
6732 int ny = -1;
6733 int i, j;
6734 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
6735 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
6736
6737 ( *jenv )->EnsureLocalCapacity( jenv, nx );
6738
6739 for ( i = 0; i < nx; i++ )
6740 {
6741 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg3, i );
6742 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
6743
6744 if ( ny == -1 )
6745 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
6746 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
6747 {
6748 printf( "Misshapen a array.\n" );
6749 for ( j = 0; j <= i; j++ )
6750 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
6751 free( adat );
6752 free( ai );
6753 return;
6754 }
6755 }
6756
6757 if ( nx != Xlen || ny != Ylen )
6758 {
6759 printf( "Vectors must match matrix.\n" );
6760 for ( i = 0; i < nx; i++ )
6761 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
6762 free( adat );
6763 free( ai );
6764 return;
6765 }
6766 setup_array_2d_d( &arg3, adat, nx, ny );
6767 arg4 = nx;
6768 arg5 = ny;
6769 for ( i = 0; i < nx; i++ )
6770 {
6771 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
6772 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
6773 }
6774
6775
6776 free( adat );
6777 free( ai );
6778 }
6779 arg6 = (PLINT)jarg6;
6780 {
6781 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg7, 0 );
6782 arg8 = ( *jenv )->GetArrayLength( jenv, jarg7 );
6783 setup_array_1d_d( &arg7, jxdata, arg8 );
6784 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg7, jxdata, 0 );
6785 }
6786 plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
6787 {
6788 free( arg1 );
6789 }
6790 {
6791 free( arg2 );
6792 }
6793 {
6794 free( arg3[0] );
6795 free( arg3 );
6796 }
6797 {
6798 free( arg7 );
6799 }
6800 }
6801
6802
6803 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) {
6804 PLFLT *arg1 = (PLFLT *) 0 ;
6805 PLFLT *arg2 = (PLFLT *) 0 ;
6806 PLFLT **arg3 = (PLFLT **) 0 ;
6807 PLINT arg4 ;
6808 PLINT arg5 ;
6809 PLINT arg6 ;
6810 PLFLT *arg7 = (PLFLT *) 0 ;
6811 PLINT arg8 ;
6812 PLINT arg9 ;
6813 PLINT arg10 ;
6814 PLINT *arg11 = (PLINT *) 0 ;
6815 PLINT *arg12 = (PLINT *) 0 ;
6816
6817 (void)jenv;
6818 (void)jcls;
6819 {
6820 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
6821 Xlen = ( *jenv )->GetArrayLength( jenv, jarg1 );
6822 setup_array_1d_d( &arg1, jxdata, Xlen );
6823 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
6824 }
6825 {
6826 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg2, 0 );
6827 Ylen = ( *jenv )->GetArrayLength( jenv, jarg2 );
6828 setup_array_1d_d( &arg2, jydata, Ylen );
6829 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );
6830 }
6831 {
6832 jdouble **adat;
6833 jobject *ai;
6834 int nx = ( *jenv )->GetArrayLength( jenv, jarg3 );
6835 int ny = -1;
6836 int i, j;
6837 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
6838 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
6839
6840 ( *jenv )->EnsureLocalCapacity( jenv, nx );
6841
6842 for ( i = 0; i < nx; i++ )
6843 {
6844 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg3, i );
6845 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
6846
6847 if ( ny == -1 )
6848 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
6849 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
6850 {
6851 printf( "Misshapen a array.\n" );
6852 for ( j = 0; j <= i; j++ )
6853 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
6854 free( adat );
6855 free( ai );
6856 return;
6857 }
6858 }
6859
6860 if ( nx != Xlen || ny != Ylen )
6861 {
6862 printf( "Vectors must match matrix.\n" );
6863 for ( i = 0; i < nx; i++ )
6864 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
6865 free( adat );
6866 free( ai );
6867 return;
6868 }
6869 setup_array_2d_d( &arg3, adat, nx, ny );
6870 arg4 = nx;
6871 arg5 = ny;
6872 for ( i = 0; i < nx; i++ )
6873 {
6874 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
6875 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
6876 }
6877
6878
6879 free( adat );
6880 free( ai );
6881 }
6882 arg6 = (PLINT)jarg6;
6883 {
6884 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg7, 0 );
6885 arg8 = ( *jenv )->GetArrayLength( jenv, jarg7 );
6886 setup_array_1d_d( &arg7, jxdata, arg8 );
6887 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg7, jxdata, 0 );
6888 }
6889 arg9 = (PLINT)jarg9;
6890 {
6891 jint *jxdata = ( *jenv )->GetIntArrayElements( jenv, jarg10, 0 );
6892 arg10 = ( *jenv )->GetArrayLength( jenv, jarg10 );
6893 Alen = arg10;
6894 setup_array_1d_i( &arg11, jxdata, Alen );
6895 // Could find no easy way to do this as part of freearg so I modified
6896 // the previous function so it ALWAYS mallocs and copies so that
6897 // the java array can be released immediately.
6898 ( *jenv )->ReleaseIntArrayElements( jenv, jarg10, jxdata, 0 );
6899 }
6900 {
6901 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg12, 0 );
6902 if ( ( *jenv )->GetArrayLength( jenv, jarg12 ) != Alen )
6903 {
6904 printf( "Vectors must be same length.\n" );
6905 return;
6906 }
6907 setup_array_1d_i( &arg12, jydata, Alen );
6908 ( *jenv )->ReleaseIntArrayElements( jenv, jarg12, jydata, 0 );
6909 }
6910 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);
6911 {
6912 free( arg1 );
6913 }
6914 {
6915 free( arg2 );
6916 }
6917 {
6918 free( arg3[0] );
6919 free( arg3 );
6920 }
6921 {
6922 free( arg7 );
6923 }
6924 {
6925 free( arg11 );
6926 }
6927 {
6928 free( arg12 );
6929 }
6930 }
6931
6932
6933 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsurf3d(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jobjectArray jarg3, jint jarg6, jdoubleArray jarg7) {
6934 PLFLT *arg1 = (PLFLT *) 0 ;
6935 PLFLT *arg2 = (PLFLT *) 0 ;
6936 PLFLT **arg3 = (PLFLT **) 0 ;
6937 PLINT arg4 ;
6938 PLINT arg5 ;
6939 PLINT arg6 ;
6940 PLFLT *arg7 = (PLFLT *) 0 ;
6941 PLINT arg8 ;
6942
6943 (void)jenv;
6944 (void)jcls;
6945 {
6946 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
6947 Xlen = ( *jenv )->GetArrayLength( jenv, jarg1 );
6948 setup_array_1d_d( &arg1, jxdata, Xlen );
6949 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
6950 }
6951 {
6952 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg2, 0 );
6953 Ylen = ( *jenv )->GetArrayLength( jenv, jarg2 );
6954 setup_array_1d_d( &arg2, jydata, Ylen );
6955 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );
6956 }
6957 {
6958 jdouble **adat;
6959 jobject *ai;
6960 int nx = ( *jenv )->GetArrayLength( jenv, jarg3 );
6961 int ny = -1;
6962 int i, j;
6963 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
6964 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
6965
6966 ( *jenv )->EnsureLocalCapacity( jenv, nx );
6967
6968 for ( i = 0; i < nx; i++ )
6969 {
6970 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg3, i );
6971 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
6972
6973 if ( ny == -1 )
6974 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
6975 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
6976 {
6977 printf( "Misshapen a array.\n" );
6978 for ( j = 0; j <= i; j++ )
6979 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
6980 free( adat );
6981 free( ai );
6982 return;
6983 }
6984 }
6985
6986 if ( nx != Xlen || ny != Ylen )
6987 {
6988 printf( "Vectors must match matrix.\n" );
6989 for ( i = 0; i < nx; i++ )
6990 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
6991 free( adat );
6992 free( ai );
6993 return;
6994 }
6995 setup_array_2d_d( &arg3, adat, nx, ny );
6996 arg4 = nx;
6997 arg5 = ny;
6998 for ( i = 0; i < nx; i++ )
6999 {
7000 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
7001 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
7002 }
7003
7004
7005 free( adat );
7006 free( ai );
7007 }
7008 arg6 = (PLINT)jarg6;
7009 {
7010 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg7, 0 );
7011 arg8 = ( *jenv )->GetArrayLength( jenv, jarg7 );
7012 setup_array_1d_d( &arg7, jxdata, arg8 );
7013 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg7, jxdata, 0 );
7014 }
7015 plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
7016 {
7017 free( arg1 );
7018 }
7019 {
7020 free( arg2 );
7021 }
7022 {
7023 free( arg3[0] );
7024 free( arg3 );
7025 }
7026 {
7027 free( arg7 );
7028 }
7029 }
7030
7031
7032 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) {
7033 PLFLT *arg1 = (PLFLT *) 0 ;
7034 PLFLT *arg2 = (PLFLT *) 0 ;
7035 PLFLT **arg3 = (PLFLT **) 0 ;
7036 PLINT arg4 ;
7037 PLINT arg5 ;
7038 PLINT arg6 ;
7039 PLFLT *arg7 = (PLFLT *) 0 ;
7040 PLINT arg8 ;
7041 PLINT arg9 ;
7042 PLINT arg10 ;
7043 PLINT *arg11 = (PLINT *) 0 ;
7044 PLINT *arg12 = (PLINT *) 0 ;
7045
7046 (void)jenv;
7047 (void)jcls;
7048 {
7049 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
7050 Xlen = ( *jenv )->GetArrayLength( jenv, jarg1 );
7051 setup_array_1d_d( &arg1, jxdata, Xlen );
7052 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
7053 }
7054 {
7055 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg2, 0 );
7056 Ylen = ( *jenv )->GetArrayLength( jenv, jarg2 );
7057 setup_array_1d_d( &arg2, jydata, Ylen );
7058 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );
7059 }
7060 {
7061 jdouble **adat;
7062 jobject *ai;
7063 int nx = ( *jenv )->GetArrayLength( jenv, jarg3 );
7064 int ny = -1;
7065 int i, j;
7066 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
7067 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
7068
7069 ( *jenv )->EnsureLocalCapacity( jenv, nx );
7070
7071 for ( i = 0; i < nx; i++ )
7072 {
7073 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg3, i );
7074 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
7075
7076 if ( ny == -1 )
7077 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
7078 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
7079 {
7080 printf( "Misshapen a array.\n" );
7081 for ( j = 0; j <= i; j++ )
7082 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
7083 free( adat );
7084 free( ai );
7085 return;
7086 }
7087 }
7088
7089 if ( nx != Xlen || ny != Ylen )
7090 {
7091 printf( "Vectors must match matrix.\n" );
7092 for ( i = 0; i < nx; i++ )
7093 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
7094 free( adat );
7095 free( ai );
7096 return;
7097 }
7098 setup_array_2d_d( &arg3, adat, nx, ny );
7099 arg4 = nx;
7100 arg5 = ny;
7101 for ( i = 0; i < nx; i++ )
7102 {
7103 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
7104 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
7105 }
7106
7107
7108 free( adat );
7109 free( ai );
7110 }
7111 arg6 = (PLINT)jarg6;
7112 {
7113 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg7, 0 );
7114 arg8 = ( *jenv )->GetArrayLength( jenv, jarg7 );
7115 setup_array_1d_d( &arg7, jxdata, arg8 );
7116 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg7, jxdata, 0 );
7117 }
7118 arg9 = (PLINT)jarg9;
7119 {
7120 jint *jxdata = ( *jenv )->GetIntArrayElements( jenv, jarg10, 0 );
7121 arg10 = ( *jenv )->GetArrayLength( jenv, jarg10 );
7122 Alen = arg10;
7123 setup_array_1d_i( &arg11, jxdata, Alen );
7124 // Could find no easy way to do this as part of freearg so I modified
7125 // the previous function so it ALWAYS mallocs and copies so that
7126 // the java array can be released immediately.
7127 ( *jenv )->ReleaseIntArrayElements( jenv, jarg10, jxdata, 0 );
7128 }
7129 {
7130 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg12, 0 );
7131 if ( ( *jenv )->GetArrayLength( jenv, jarg12 ) != Alen )
7132 {
7133 printf( "Vectors must be same length.\n" );
7134 return;
7135 }
7136 setup_array_1d_i( &arg12, jydata, Alen );
7137 ( *jenv )->ReleaseIntArrayElements( jenv, jarg12, jydata, 0 );
7138 }
7139 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);
7140 {
7141 free( arg1 );
7142 }
7143 {
7144 free( arg2 );
7145 }
7146 {
7147 free( arg3[0] );
7148 free( arg3 );
7149 }
7150 {
7151 free( arg7 );
7152 }
7153 {
7154 free( arg11 );
7155 }
7156 {
7157 free( arg12 );
7158 }
7159 }
7160
7161
7162 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_plparseopts(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jint jarg3) {
7163 jint jresult = 0 ;
7164 int *arg1 = (int *) 0 ;
7165 char **arg2 = (char **) 0 ;
7166 PLINT arg3 ;
7167 int size1 ;
7168 PLINT result;
7169
7170 (void)jenv;
7171 (void)jcls;
7172 {
7173 int i = 0;
7174 size1 = (int) ( ( *jenv )->GetArrayLength( jenv, jarg1 ) );
7175 arg1 = &size1;
7176 arg2 = (char **) malloc( (size_t) ( size1 + 1 ) * sizeof ( char * ) );
7177 // make a copy of each string
7178 for ( i = 0; i < size1; i++ )
7179 {
7180 jstring j_string = (jstring) ( *jenv )->GetObjectArrayElement( jenv, jarg1, i );
7181 const char * c_string = (char *) ( *jenv )->GetStringUTFChars( jenv, j_string, 0 );
7182 // Commented out version straight from swig documentation, but I think
7183 // it is wrong.
7184 // arg2[i] = malloc(strlen((c_string)+1)*sizeof(const char *));
7185 arg2[i] = malloc( ( strlen( c_string ) + 1 ) * sizeof ( const char * ) );
7186 strcpy( arg2[i], c_string );
7187 ( *jenv )->ReleaseStringUTFChars( jenv, j_string, c_string );
7188 ( *jenv )->DeleteLocalRef( jenv, j_string );
7189 }
7190 arg2[i] = 0;
7191 }
7192 arg3 = (PLINT)jarg3;
7193 result = (PLINT)plparseopts(arg1,(char const **)arg2,arg3);
7194 jresult = (jint)result;
7195 {
7196 int i;
7197 // Commented out version straight from swig documentation, but I think
7198 // it is wrong.
7199 // for (i=0; i<size1-1; i++)
7200 for ( i = 0; i < size1; i++ )
7201 free( arg2[i] );
7202 free( arg2 );
7203 }
7204 return jresult;
7205 }
7206
7207
7208 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plpat(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg3) {
7209 PLINT arg1 ;
7210 PLINT *arg2 = (PLINT *) 0 ;
7211 PLINT *arg3 = (PLINT *) 0 ;
7212
7213 (void)jenv;
7214 (void)jcls;
7215 {
7216 jint *jxdata = ( *jenv )->GetIntArrayElements( jenv, jarg1, 0 );
7217 arg1 = ( *jenv )->GetArrayLength( jenv, jarg1 );
7218 Alen = arg1;
7219 setup_array_1d_i( &arg2, jxdata, Alen );
7220 // Could find no easy way to do this as part of freearg so I modified
7221 // the previous function so it ALWAYS mallocs and copies so that
7222 // the java array can be released immediately.
7223 ( *jenv )->ReleaseIntArrayElements( jenv, jarg1, jxdata, 0 );
7224 }
7225 {
7226 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg3, 0 );
7227 if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
7228 {
7229 printf( "Vectors must be same length.\n" );
7230 return;
7231 }
7232 setup_array_1d_i( &arg3, jydata, Alen );
7233 ( *jenv )->ReleaseIntArrayElements( jenv, jarg3, jydata, 0 );
7234 }
7235 plpat(arg1,(int const *)arg2,(int const *)arg3);
7236 {
7237 free( arg2 );
7238 }
7239 {
7240 free( arg3 );
7241 }
7242 }
7243
7244
7245 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plpath(JNIEnv *jenv, jclass jcls, jint jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4, jdouble jarg5) {
7246 PLINT arg1 ;
7247 PLFLT arg2 ;
7248 PLFLT arg3 ;
7249 PLFLT arg4 ;
7250 PLFLT arg5 ;
7251
7252 (void)jenv;
7253 (void)jcls;
7254 arg1 = (PLINT)jarg1;
7255 arg2 = (PLFLT)jarg2;
7256 arg3 = (PLFLT)jarg3;
7257 arg4 = (PLFLT)jarg4;
7258 arg5 = (PLFLT)jarg5;
7259 plpath(arg1,arg2,arg3,arg4,arg5);
7260 }
7261
7262
7263 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plpoin(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jint jarg4) {
7264 PLINT arg1 ;
7265 PLFLT *arg2 = (PLFLT *) 0 ;
7266 PLFLT *arg3 = (PLFLT *) 0 ;
7267 PLINT arg4 ;
7268
7269 (void)jenv;
7270 (void)jcls;
7271 {
7272 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
7273 arg1 = ( *jenv )->GetArrayLength( jenv, jarg1 );
7274 Alen = arg1;
7275 setup_array_1d_d( &arg2, jxdata, Alen );
7276 // Could find no easy way to do this as part of freearg so I modified
7277 // the previous function so it ALWAYS mallocs and copies so that
7278 // the java array can be released immediately.
7279 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
7280 }
7281 {
7282 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
7283 if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
7284 {
7285 printf( "Vectors must be same length.\n" );
7286 return;
7287 }
7288 setup_array_1d_d( &arg3, jydata, Alen );
7289 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
7290 }
7291 arg4 = (PLINT)jarg4;
7292 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
7293 {
7294 free( arg2 );
7295 }
7296 {
7297 free( arg3 );
7298 }
7299 }
7300
7301
7302 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plpoin3(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jdoubleArray jarg4, jint jarg5) {
7303 PLINT arg1 ;
7304 PLFLT *arg2 = (PLFLT *) 0 ;
7305 PLFLT *arg3 = (PLFLT *) 0 ;
7306 PLFLT *arg4 = (PLFLT *) 0 ;
7307 PLINT arg5 ;
7308
7309 (void)jenv;
7310 (void)jcls;
7311 {
7312 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
7313 arg1 = ( *jenv )->GetArrayLength( jenv, jarg1 );
7314 Alen = arg1;
7315 setup_array_1d_d( &arg2, jxdata, Alen );
7316 // Could find no easy way to do this as part of freearg so I modified
7317 // the previous function so it ALWAYS mallocs and copies so that
7318 // the java array can be released immediately.
7319 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
7320 }
7321 {
7322 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
7323 if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
7324 {
7325 printf( "Vectors must be same length.\n" );
7326 return;
7327 }
7328 setup_array_1d_d( &arg3, jydata, Alen );
7329 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
7330 }
7331 {
7332 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg4, 0 );
7333 if ( ( *jenv )->GetArrayLength( jenv, jarg4 ) != Alen )
7334 {
7335 printf( "Vectors must be same length.\n" );
7336 return;
7337 }
7338 setup_array_1d_d( &arg4, jydata, Alen );
7339 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );
7340 }
7341 arg5 = (PLINT)jarg5;
7342 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
7343 {
7344 free( arg2 );
7345 }
7346 {
7347 free( arg3 );
7348 }
7349 {
7350 free( arg4 );
7351 }
7352 }
7353
7354
7355 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plpoly3(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jdoubleArray jarg4, jbooleanArray jarg5, jboolean jarg6) {
7356 PLINT arg1 ;
7357 PLFLT *arg2 = (PLFLT *) 0 ;
7358 PLFLT *arg3 = (PLFLT *) 0 ;
7359 PLFLT *arg4 = (PLFLT *) 0 ;
7360 PLBOOL *arg5 = (PLBOOL *) 0 ;
7361 PLBOOL arg6 ;
7362
7363 (void)jenv;
7364 (void)jcls;
7365 {
7366 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
7367 arg1 = ( *jenv )->GetArrayLength( jenv, jarg1 );
7368 Alen = arg1;
7369 setup_array_1d_d( &arg2, jxdata, Alen );
7370 // Could find no easy way to do this as part of freearg so I modified
7371 // the previous function so it ALWAYS mallocs and copies so that
7372 // the java array can be released immediately.
7373 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
7374 }
7375 {
7376 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
7377 if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
7378 {
7379 printf( "Vectors must be same length.\n" );
7380 return;
7381 }
7382 setup_array_1d_d( &arg3, jydata, Alen );
7383 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
7384 }
7385 {
7386 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg4, 0 );
7387 if ( ( *jenv )->GetArrayLength( jenv, jarg4 ) != Alen )
7388 {
7389 printf( "Vectors must be same length.\n" );
7390 return;
7391 }
7392 setup_array_1d_d( &arg4, jydata, Alen );
7393 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );
7394 }
7395 {
7396 jboolean *jydata = ( *jenv )->GetBooleanArrayElements( jenv, jarg5, 0 );
7397 if ( ( *jenv )->GetArrayLength( jenv, jarg5 ) < Alen - 1 )
7398 {
7399 printf( "Vector must be at least length of others minus 1.\n" );
7400 return;
7401 }
7402 setup_array_1d_b( &arg5, jydata, Alen );
7403 ( *jenv )->ReleaseBooleanArrayElements( jenv, jarg5, jydata, 0 );
7404 }
7405
7406 arg6 = jarg6 ? 1 : 0;
7407
7408 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
7409 {
7410 free( arg2 );
7411 }
7412 {
7413 free( arg3 );
7414 }
7415 {
7416 free( arg4 );
7417 }
7418 {
7419 free( arg5 );
7420 }
7421 }
7422
7423
7424 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plprec(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {
7425 PLINT arg1 ;
7426 PLINT arg2 ;
7427
7428 (void)jenv;
7429 (void)jcls;
7430 arg1 = (PLINT)jarg1;
7431 arg2 = (PLINT)jarg2;
7432 plprec(arg1,arg2);
7433 }
7434
7435
7436 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plpsty(JNIEnv *jenv, jclass jcls, jint jarg1) {
7437 PLINT arg1 ;
7438
7439 (void)jenv;
7440 (void)jcls;
7441 arg1 = (PLINT)jarg1;
7442 plpsty(arg1);
7443 }
7444
7445
7446 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plptex(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4, jdouble jarg5, jstring jarg6) {
7447 PLFLT arg1 ;
7448 PLFLT arg2 ;
7449 PLFLT arg3 ;
7450 PLFLT arg4 ;
7451 PLFLT arg5 ;
7452 char *arg6 = (char *) 0 ;
7453
7454 (void)jenv;
7455 (void)jcls;
7456 arg1 = (PLFLT)jarg1;
7457 arg2 = (PLFLT)jarg2;
7458 arg3 = (PLFLT)jarg3;
7459 arg4 = (PLFLT)jarg4;
7460 arg5 = (PLFLT)jarg5;
7461 arg6 = 0;
7462 if (jarg6) {
7463 arg6 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg6, 0);
7464 if (!arg6) return ;
7465 }
7466 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
7467 if (arg6) (*jenv)->ReleaseStringUTFChars(jenv, jarg6, (const char *)arg6);
7468 }
7469
7470
7471 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) {
7472 PLFLT arg1 ;
7473 PLFLT arg2 ;
7474 PLFLT arg3 ;
7475 PLFLT arg4 ;
7476 PLFLT arg5 ;
7477 PLFLT arg6 ;
7478 PLFLT arg7 ;
7479 PLFLT arg8 ;
7480 PLFLT arg9 ;
7481 PLFLT arg10 ;
7482 char *arg11 = (char *) 0 ;
7483
7484 (void)jenv;
7485 (void)jcls;
7486 arg1 = (PLFLT)jarg1;
7487 arg2 = (PLFLT)jarg2;
7488 arg3 = (PLFLT)jarg3;
7489 arg4 = (PLFLT)jarg4;
7490 arg5 = (PLFLT)jarg5;
7491 arg6 = (PLFLT)jarg6;
7492 arg7 = (PLFLT)jarg7;
7493 arg8 = (PLFLT)jarg8;
7494 arg9 = (PLFLT)jarg9;
7495 arg10 = (PLFLT)jarg10;
7496 arg11 = 0;
7497 if (jarg11) {
7498 arg11 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg11, 0);
7499 if (!arg11) return ;
7500 }
7501 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
7502 if (arg11) (*jenv)->ReleaseStringUTFChars(jenv, jarg11, (const char *)arg11);
7503 }
7504
7505
7506 SWIGEXPORT jdouble JNICALL Java_plplot_core_plplotjavacJNI_plrandd(JNIEnv *jenv, jclass jcls) {
7507 jdouble jresult = 0 ;
7508 PLFLT result;
7509
7510 (void)jenv;
7511 (void)jcls;
7512 result = (PLFLT)plrandd();
7513 jresult = (jdouble)result;
7514 return jresult;
7515 }
7516
7517
7518 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plreplot(JNIEnv *jenv, jclass jcls) {
7519 (void)jenv;
7520 (void)jcls;
7521 plreplot();
7522 }
7523
7524
7525 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plrgbhls(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdoubleArray jarg4, jdoubleArray jarg5, jdoubleArray jarg6) {
7526 PLFLT arg1 ;
7527 PLFLT arg2 ;
7528 PLFLT arg3 ;
7529 PLFLT *arg4 = (PLFLT *) 0 ;
7530 PLFLT *arg5 = (PLFLT *) 0 ;
7531 PLFLT *arg6 = (PLFLT *) 0 ;
7532 PLFLT temp4 ;
7533 PLFLT temp5 ;
7534 PLFLT temp6 ;
7535
7536 (void)jenv;
7537 (void)jcls;
7538 arg1 = (PLFLT)jarg1;
7539 arg2 = (PLFLT)jarg2;
7540 arg3 = (PLFLT)jarg3;
7541 {
7542 if (!jarg4) {
7543 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
7544 return ;
7545 }
7546 if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
7547 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
7548 return ;
7549 }
7550 temp4 = (PLFLT)0;
7551 arg4 = &temp4;
7552 }
7553 {
7554 if (!jarg5) {
7555 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
7556 return ;
7557 }
7558 if ((*jenv)->GetArrayLength(jenv, jarg5) == 0) {
7559 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
7560 return ;
7561 }
7562 temp5 = (PLFLT)0;
7563 arg5 = &temp5;
7564 }
7565 {
7566 if (!jarg6) {
7567 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
7568 return ;
7569 }
7570 if ((*jenv)->GetArrayLength(jenv, jarg6) == 0) {
7571 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
7572 return ;
7573 }
7574 temp6 = (PLFLT)0;
7575 arg6 = &temp6;
7576 }
7577 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
7578 {
7579 jdouble jvalue = (jdouble)temp4;
7580 (*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);
7581 }
7582 {
7583 jdouble jvalue = (jdouble)temp5;
7584 (*jenv)->SetDoubleArrayRegion(jenv, jarg5, 0, 1, &jvalue);
7585 }
7586 {
7587 jdouble jvalue = (jdouble)temp6;
7588 (*jenv)->SetDoubleArrayRegion(jenv, jarg6, 0, 1, &jvalue);
7589 }
7590
7591
7592
7593 }
7594
7595
7596 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plschr(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2) {
7597 PLFLT arg1 ;
7598 PLFLT arg2 ;
7599
7600 (void)jenv;
7601 (void)jcls;
7602 arg1 = (PLFLT)jarg1;
7603 arg2 = (PLFLT)jarg2;
7604 plschr(arg1,arg2);
7605 }
7606
7607
7608 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscmap0(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2, jintArray jarg3) {
7609 PLINT *arg1 = (PLINT *) 0 ;
7610 PLINT *arg2 = (PLINT *) 0 ;
7611 PLINT *arg3 = (PLINT *) 0 ;
7612 PLINT arg4 ;
7613
7614 (void)jenv;
7615 (void)jcls;
7616 {
7617 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg1, 0 );
7618 Alen = ( *jenv )->GetArrayLength( jenv, jarg1 );
7619 setup_array_1d_i( &arg1, jydata, Alen );
7620 ( *jenv )->ReleaseIntArrayElements( jenv, jarg1, jydata, 0 );
7621 }
7622 {
7623 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg2, 0 );
7624 if ( ( *jenv )->GetArrayLength( jenv, jarg2 ) != Alen )
7625 {
7626 printf( "Vectors must be same length.\n" );
7627 return;
7628 }
7629 setup_array_1d_i( &arg2, jydata, Alen );
7630 ( *jenv )->ReleaseIntArrayElements( jenv, jarg2, jydata, 0 );
7631 }
7632 {
7633 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg3, 0 );
7634 if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
7635 {
7636 printf( "Vectors must be same length.\n" );
7637 return;
7638 }
7639 arg4 = ( *jenv )->GetArrayLength( jenv, jarg3 );
7640 setup_array_1d_i( &arg3, jydata, Alen );
7641 ( *jenv )->ReleaseIntArrayElements( jenv, jarg3, jydata, 0 );
7642 }
7643 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
7644 {
7645 free( arg1 );
7646 }
7647 {
7648 free( arg2 );
7649 }
7650 {
7651 free( arg3 );
7652 }
7653 }
7654
7655
7656 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscmap0a(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2, jintArray jarg3, jdoubleArray jarg4) {
7657 PLINT *arg1 = (PLINT *) 0 ;
7658 PLINT *arg2 = (PLINT *) 0 ;
7659 PLINT *arg3 = (PLINT *) 0 ;
7660 PLFLT *arg4 = (PLFLT *) 0 ;
7661 PLINT arg5 ;
7662
7663 (void)jenv;
7664 (void)jcls;
7665 {
7666 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg1, 0 );
7667 Alen = ( *jenv )->GetArrayLength( jenv, jarg1 );
7668 setup_array_1d_i( &arg1, jydata, Alen );
7669 ( *jenv )->ReleaseIntArrayElements( jenv, jarg1, jydata, 0 );
7670 }
7671 {
7672 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg2, 0 );
7673 if ( ( *jenv )->GetArrayLength( jenv, jarg2 ) != Alen )
7674 {
7675 printf( "Vectors must be same length.\n" );
7676 return;
7677 }
7678 setup_array_1d_i( &arg2, jydata, Alen );
7679 ( *jenv )->ReleaseIntArrayElements( jenv, jarg2, jydata, 0 );
7680 }
7681 {
7682 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg3, 0 );
7683 if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
7684 {
7685 printf( "Vectors must be same length.\n" );
7686 return;
7687 }
7688 setup_array_1d_i( &arg3, jydata, Alen );
7689 ( *jenv )->ReleaseIntArrayElements( jenv, jarg3, jydata, 0 );
7690 }
7691 {
7692 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg4, 0 );
7693 arg5 = ( *jenv )->GetArrayLength( jenv, jarg4 );
7694 if ( ( *jenv )->GetArrayLength( jenv, jarg4 ) != Alen )
7695 {
7696 printf( "Vectors must be same length.\n" );
7697 return;
7698 }
7699 setup_array_1d_d( &arg4, jydata, Alen );
7700 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );
7701 }
7702 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
7703 {
7704 free( arg1 );
7705 }
7706 {
7707 free( arg2 );
7708 }
7709 {
7710 free( arg3 );
7711 }
7712 {
7713 free( arg4 );
7714 }
7715 }
7716
7717
7718 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscmap0n(JNIEnv *jenv, jclass jcls, jint jarg1) {
7719 PLINT arg1 ;
7720
7721 (void)jenv;
7722 (void)jcls;
7723 arg1 = (PLINT)jarg1;
7724 plscmap0n(arg1);
7725 }
7726
7727
7728 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscmap1(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2, jintArray jarg3) {
7729 PLINT *arg1 = (PLINT *) 0 ;
7730 PLINT *arg2 = (PLINT *) 0 ;
7731 PLINT *arg3 = (PLINT *) 0 ;
7732 PLINT arg4 ;
7733
7734 (void)jenv;
7735 (void)jcls;
7736 {
7737 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg1, 0 );
7738 Alen = ( *jenv )->GetArrayLength( jenv, jarg1 );
7739 setup_array_1d_i( &arg1, jydata, Alen );
7740 ( *jenv )->ReleaseIntArrayElements( jenv, jarg1, jydata, 0 );
7741 }
7742 {
7743 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg2, 0 );
7744 if ( ( *jenv )->GetArrayLength( jenv, jarg2 ) != Alen )
7745 {
7746 printf( "Vectors must be same length.\n" );
7747 return;
7748 }
7749 setup_array_1d_i( &arg2, jydata, Alen );
7750 ( *jenv )->ReleaseIntArrayElements( jenv, jarg2, jydata, 0 );
7751 }
7752 {
7753 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg3, 0 );
7754 if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
7755 {
7756 printf( "Vectors must be same length.\n" );
7757 return;
7758 }
7759 arg4 = ( *jenv )->GetArrayLength( jenv, jarg3 );
7760 setup_array_1d_i( &arg3, jydata, Alen );
7761 ( *jenv )->ReleaseIntArrayElements( jenv, jarg3, jydata, 0 );
7762 }
7763 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
7764 {
7765 free( arg1 );
7766 }
7767 {
7768 free( arg2 );
7769 }
7770 {
7771 free( arg3 );
7772 }
7773 }
7774
7775
7776 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscmap1a(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2, jintArray jarg3, jdoubleArray jarg4) {
7777 PLINT *arg1 = (PLINT *) 0 ;
7778 PLINT *arg2 = (PLINT *) 0 ;
7779 PLINT *arg3 = (PLINT *) 0 ;
7780 PLFLT *arg4 = (PLFLT *) 0 ;
7781 PLINT arg5 ;
7782
7783 (void)jenv;
7784 (void)jcls;
7785 {
7786 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg1, 0 );
7787 Alen = ( *jenv )->GetArrayLength( jenv, jarg1 );
7788 setup_array_1d_i( &arg1, jydata, Alen );
7789 ( *jenv )->ReleaseIntArrayElements( jenv, jarg1, jydata, 0 );
7790 }
7791 {
7792 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg2, 0 );
7793 if ( ( *jenv )->GetArrayLength( jenv, jarg2 ) != Alen )
7794 {
7795 printf( "Vectors must be same length.\n" );
7796 return;
7797 }
7798 setup_array_1d_i( &arg2, jydata, Alen );
7799 ( *jenv )->ReleaseIntArrayElements( jenv, jarg2, jydata, 0 );
7800 }
7801 {
7802 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg3, 0 );
7803 if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
7804 {
7805 printf( "Vectors must be same length.\n" );
7806 return;
7807 }
7808 setup_array_1d_i( &arg3, jydata, Alen );
7809 ( *jenv )->ReleaseIntArrayElements( jenv, jarg3, jydata, 0 );
7810 }
7811 {
7812 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg4, 0 );
7813 arg5 = ( *jenv )->GetArrayLength( jenv, jarg4 );
7814 if ( ( *jenv )->GetArrayLength( jenv, jarg4 ) != Alen )
7815 {
7816 printf( "Vectors must be same length.\n" );
7817 return;
7818 }
7819 setup_array_1d_d( &arg4, jydata, Alen );
7820 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );
7821 }
7822 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
7823 {
7824 free( arg1 );
7825 }
7826 {
7827 free( arg2 );
7828 }
7829 {
7830 free( arg3 );
7831 }
7832 {
7833 free( arg4 );
7834 }
7835 }
7836
7837
7838 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscmap1l(JNIEnv *jenv, jclass jcls, jboolean jarg1, jdoubleArray jarg2, jdoubleArray jarg4, jdoubleArray jarg5, jdoubleArray jarg6, jbooleanArray jarg7) {
7839 PLBOOL arg1 ;
7840 PLINT arg2 ;
7841 PLFLT *arg3 = (PLFLT *) 0 ;
7842 PLFLT *arg4 = (PLFLT *) 0 ;
7843 PLFLT *arg5 = (PLFLT *) 0 ;
7844 PLFLT *arg6 = (PLFLT *) 0 ;
7845 PLBOOL *arg7 = (PLBOOL *) 0 ;
7846
7847 (void)jenv;
7848 (void)jcls;
7849
7850 arg1 = jarg1 ? 1 : 0;
7851
7852 {
7853 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg2, 0 );
7854 arg2 = ( *jenv )->GetArrayLength( jenv, jarg2 );
7855 Alen = arg2;
7856 setup_array_1d_d( &arg3, jxdata, Alen );
7857 // Could find no easy way to do this as part of freearg so I modified
7858 // the previous function so it ALWAYS mallocs and copies so that
7859 // the java array can be released immediately.
7860 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg2, jxdata, 0 );
7861 }
7862 {
7863 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg4, 0 );
7864 if ( ( *jenv )->GetArrayLength( jenv, jarg4 ) != Alen )
7865 {
7866 printf( "Vectors must be same length.\n" );
7867 return;
7868 }
7869 setup_array_1d_d( &arg4, jydata, Alen );
7870 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );
7871 }
7872 {
7873 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg5, 0 );
7874 if ( ( *jenv )->GetArrayLength( jenv, jarg5 ) != Alen )
7875 {
7876 printf( "Vectors must be same length.\n" );
7877 return;
7878 }
7879 setup_array_1d_d( &arg5, jydata, Alen );
7880 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg5, jydata, 0 );
7881 }
7882 {
7883 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg6, 0 );
7884 if ( ( *jenv )->GetArrayLength( jenv, jarg6 ) != Alen )
7885 {
7886 printf( "Vectors must be same length.\n" );
7887 return;
7888 }
7889 setup_array_1d_d( &arg6, jydata, Alen );
7890 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg6, jydata, 0 );
7891 }
7892 {
7893 if ( jarg7 != NULL )
7894 {
7895 jboolean *jydata = ( *jenv )->GetBooleanArrayElements( jenv, jarg7, 0 );
7896 if ( ( *jenv )->GetArrayLength( jenv, jarg7 ) < Alen - 1 )
7897 {
7898 printf( "Vector must be at least length of others minus 1.\n" );
7899 return;
7900 }
7901 setup_array_1d_b( &arg7, jydata, Alen );
7902 ( *jenv )->ReleaseBooleanArrayElements( jenv, jarg7, jydata, 0 );
7903 }
7904 else
7905 {
7906 arg7 = NULL;
7907 }
7908 }
7909 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
7910 {
7911 free( arg3 );
7912 }
7913 {
7914 free( arg4 );
7915 }
7916 {
7917 free( arg5 );
7918 }
7919 {
7920 free( arg6 );
7921 }
7922 {
7923 if ( arg7 != NULL )
7924 free( arg7 );
7925 }
7926 }
7927
7928
7929 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) {
7930 PLBOOL arg1 ;
7931 PLINT arg2 ;
7932 PLFLT *arg3 = (PLFLT *) 0 ;
7933 PLFLT *arg4 = (PLFLT *) 0 ;
7934 PLFLT *arg5 = (PLFLT *) 0 ;
7935 PLFLT *arg6 = (PLFLT *) 0 ;
7936 PLFLT *arg7 = (PLFLT *) 0 ;
7937 PLBOOL *arg8 = (PLBOOL *) 0 ;
7938
7939 (void)jenv;
7940 (void)jcls;
7941
7942 arg1 = jarg1 ? 1 : 0;
7943
7944 {
7945 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg2, 0 );
7946 arg2 = ( *jenv )->GetArrayLength( jenv, jarg2 );
7947 Alen = arg2;
7948 setup_array_1d_d( &arg3, jxdata, Alen );
7949 // Could find no easy way to do this as part of freearg so I modified
7950 // the previous function so it ALWAYS mallocs and copies so that
7951 // the java array can be released immediately.
7952 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg2, jxdata, 0 );
7953 }
7954 {
7955 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg4, 0 );
7956 if ( ( *jenv )->GetArrayLength( jenv, jarg4 ) != Alen )
7957 {
7958 printf( "Vectors must be same length.\n" );
7959 return;
7960 }
7961 setup_array_1d_d( &arg4, jydata, Alen );
7962 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );
7963 }
7964 {
7965 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg5, 0 );
7966 if ( ( *jenv )->GetArrayLength( jenv, jarg5 ) != Alen )
7967 {
7968 printf( "Vectors must be same length.\n" );
7969 return;
7970 }
7971 setup_array_1d_d( &arg5, jydata, Alen );
7972 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg5, jydata, 0 );
7973 }
7974 {
7975 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg6, 0 );
7976 if ( ( *jenv )->GetArrayLength( jenv, jarg6 ) != Alen )
7977 {
7978 printf( "Vectors must be same length.\n" );
7979 return;
7980 }
7981 setup_array_1d_d( &arg6, jydata, Alen );
7982 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg6, jydata, 0 );
7983 }
7984 {
7985 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg7, 0 );
7986 if ( ( *jenv )->GetArrayLength( jenv, jarg7 ) != Alen )
7987 {
7988 printf( "Vectors must be same length.\n" );
7989 return;
7990 }
7991 setup_array_1d_d( &arg7, jydata, Alen );
7992 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg7, jydata, 0 );
7993 }
7994 {
7995 if ( jarg8 != NULL )
7996 {
7997 jboolean *jydata = ( *jenv )->GetBooleanArrayElements( jenv, jarg8, 0 );
7998 if ( ( *jenv )->GetArrayLength( jenv, jarg8 ) < Alen - 1 )
7999 {
8000 printf( "Vector must be at least length of others minus 1.\n" );
8001 return;
8002 }
8003 setup_array_1d_b( &arg8, jydata, Alen );
8004 ( *jenv )->ReleaseBooleanArrayElements( jenv, jarg8, jydata, 0 );
8005 }
8006 else
8007 {
8008 arg8 = NULL;
8009 }
8010 }
8011 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
8012 {
8013 free( arg3 );
8014 }
8015 {
8016 free( arg4 );
8017 }
8018 {
8019 free( arg5 );
8020 }
8021 {
8022 free( arg6 );
8023 }
8024 {
8025 free( arg7 );
8026 }
8027 {
8028 if ( arg8 != NULL )
8029 free( arg8 );
8030 }
8031 }
8032
8033
8034 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscmap1n(JNIEnv *jenv, jclass jcls, jint jarg1) {
8035 PLINT arg1 ;
8036
8037 (void)jenv;
8038 (void)jcls;
8039 arg1 = (PLINT)jarg1;
8040 plscmap1n(arg1);
8041 }
8042
8043
8044 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscmap1_1range(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2) {
8045 PLFLT arg1 ;
8046 PLFLT arg2 ;
8047
8048 (void)jenv;
8049 (void)jcls;
8050 arg1 = (PLFLT)jarg1;
8051 arg2 = (PLFLT)jarg2;
8052 plscmap1_range(arg1,arg2);
8053 }
8054
8055
8056 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgcmap1_1range(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2) {
8057 PLFLT *arg1 = (PLFLT *) 0 ;
8058 PLFLT *arg2 = (PLFLT *) 0 ;
8059 PLFLT temp1 ;
8060 PLFLT temp2 ;
8061
8062 (void)jenv;
8063 (void)jcls;
8064 {
8065 if (!jarg1) {
8066 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
8067 return ;
8068 }
8069 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
8070 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
8071 return ;
8072 }
8073 temp1 = (PLFLT)0;
8074 arg1 = &temp1;
8075 }
8076 {
8077 if (!jarg2) {
8078 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
8079 return ;
8080 }
8081 if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {
8082 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
8083 return ;
8084 }
8085 temp2 = (PLFLT)0;
8086 arg2 = &temp2;
8087 }
8088 plgcmap1_range(arg1,arg2);
8089 {
8090 jdouble jvalue = (jdouble)temp1;
8091 (*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);
8092 }
8093 {
8094 jdouble jvalue = (jdouble)temp2;
8095 (*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);
8096 }
8097
8098
8099 }
8100
8101
8102 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscol0(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3, jint jarg4) {
8103 PLINT arg1 ;
8104 PLINT arg2 ;
8105 PLINT arg3 ;
8106 PLINT arg4 ;
8107
8108 (void)jenv;
8109 (void)jcls;
8110 arg1 = (PLINT)jarg1;
8111 arg2 = (PLINT)jarg2;
8112 arg3 = (PLINT)jarg3;
8113 arg4 = (PLINT)jarg4;
8114 plscol0(arg1,arg2,arg3,arg4);
8115 }
8116
8117
8118 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscol0a(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3, jint jarg4, jdouble jarg5) {
8119 PLINT arg1 ;
8120 PLINT arg2 ;
8121 PLINT arg3 ;
8122 PLINT arg4 ;
8123 PLFLT arg5 ;
8124
8125 (void)jenv;
8126 (void)jcls;
8127 arg1 = (PLINT)jarg1;
8128 arg2 = (PLINT)jarg2;
8129 arg3 = (PLINT)jarg3;
8130 arg4 = (PLINT)jarg4;
8131 arg5 = (PLFLT)jarg5;
8132 plscol0a(arg1,arg2,arg3,arg4,arg5);
8133 }
8134
8135
8136 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscolbg(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3) {
8137 PLINT arg1 ;
8138 PLINT arg2 ;
8139 PLINT arg3 ;
8140
8141 (void)jenv;
8142 (void)jcls;
8143 arg1 = (PLINT)jarg1;
8144 arg2 = (PLINT)jarg2;
8145 arg3 = (PLINT)jarg3;
8146 plscolbg(arg1,arg2,arg3);
8147 }
8148
8149
8150 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscolbga(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3, jdouble jarg4) {
8151 PLINT arg1 ;
8152 PLINT arg2 ;
8153 PLINT arg3 ;
8154 PLFLT arg4 ;
8155
8156 (void)jenv;
8157 (void)jcls;
8158 arg1 = (PLINT)jarg1;
8159 arg2 = (PLINT)jarg2;
8160 arg3 = (PLINT)jarg3;
8161 arg4 = (PLFLT)jarg4;
8162 plscolbga(arg1,arg2,arg3,arg4);
8163 }
8164
8165
8166 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscolor(JNIEnv *jenv, jclass jcls, jint jarg1) {
8167 PLINT arg1 ;
8168
8169 (void)jenv;
8170 (void)jcls;
8171 arg1 = (PLINT)jarg1;
8172 plscolor(arg1);
8173 }
8174
8175
8176 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscompression(JNIEnv *jenv, jclass jcls, jint jarg1) {
8177 PLINT arg1 ;
8178
8179 (void)jenv;
8180 (void)jcls;
8181 arg1 = (PLINT)jarg1;
8182 plscompression(arg1);
8183 }
8184
8185
8186 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsdev(JNIEnv *jenv, jclass jcls, jstring jarg1) {
8187 char *arg1 = (char *) 0 ;
8188
8189 (void)jenv;
8190 (void)jcls;
8191 arg1 = 0;
8192 if (jarg1) {
8193 arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
8194 if (!arg1) return ;
8195 }
8196 plsdev((char const *)arg1);
8197 if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
8198 }
8199
8200
8201 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsdidev(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4) {
8202 PLFLT arg1 ;
8203 PLFLT arg2 ;
8204 PLFLT arg3 ;
8205 PLFLT arg4 ;
8206
8207 (void)jenv;
8208 (void)jcls;
8209 arg1 = (PLFLT)jarg1;
8210 arg2 = (PLFLT)jarg2;
8211 arg3 = (PLFLT)jarg3;
8212 arg4 = (PLFLT)jarg4;
8213 plsdidev(arg1,arg2,arg3,arg4);
8214 }
8215
8216
8217 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsdimap(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3, jint jarg4, jdouble jarg5, jdouble jarg6) {
8218 PLINT arg1 ;
8219 PLINT arg2 ;
8220 PLINT arg3 ;
8221 PLINT arg4 ;
8222 PLFLT arg5 ;
8223 PLFLT arg6 ;
8224
8225 (void)jenv;
8226 (void)jcls;
8227 arg1 = (PLINT)jarg1;
8228 arg2 = (PLINT)jarg2;
8229 arg3 = (PLINT)jarg3;
8230 arg4 = (PLINT)jarg4;
8231 arg5 = (PLFLT)jarg5;
8232 arg6 = (PLFLT)jarg6;
8233 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
8234 }
8235
8236
8237 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsdiori(JNIEnv *jenv, jclass jcls, jdouble jarg1) {
8238 PLFLT arg1 ;
8239
8240 (void)jenv;
8241 (void)jcls;
8242 arg1 = (PLFLT)jarg1;
8243 plsdiori(arg1);
8244 }
8245
8246
8247 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsdiplt(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4) {
8248 PLFLT arg1 ;
8249 PLFLT arg2 ;
8250 PLFLT arg3 ;
8251 PLFLT arg4 ;
8252
8253 (void)jenv;
8254 (void)jcls;
8255 arg1 = (PLFLT)jarg1;
8256 arg2 = (PLFLT)jarg2;
8257 arg3 = (PLFLT)jarg3;
8258 arg4 = (PLFLT)jarg4;
8259 plsdiplt(arg1,arg2,arg3,arg4);
8260 }
8261
8262
8263 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsdiplz(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4) {
8264 PLFLT arg1 ;
8265 PLFLT arg2 ;
8266 PLFLT arg3 ;
8267 PLFLT arg4 ;
8268
8269 (void)jenv;
8270 (void)jcls;
8271 arg1 = (PLFLT)jarg1;
8272 arg2 = (PLFLT)jarg2;
8273 arg3 = (PLFLT)jarg3;
8274 arg4 = (PLFLT)jarg4;
8275 plsdiplz(arg1,arg2,arg3,arg4);
8276 }
8277
8278
8279 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plseed(JNIEnv *jenv, jclass jcls, jlong jarg1) {
8280 unsigned int arg1 ;
8281
8282 (void)jenv;
8283 (void)jcls;
8284 arg1 = (unsigned int)jarg1;
8285 plseed(arg1);
8286 }
8287
8288
8289 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsesc(JNIEnv *jenv, jclass jcls, jchar jarg1) {
8290 char arg1 ;
8291
8292 (void)jenv;
8293 (void)jcls;
8294 arg1 = (char)jarg1;
8295 plsesc(arg1);
8296 }
8297
8298
8299 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_plsetopt(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
8300 jint jresult = 0 ;
8301 char *arg1 = (char *) 0 ;
8302 char *arg2 = (char *) 0 ;
8303 PLINT result;
8304
8305 (void)jenv;
8306 (void)jcls;
8307 arg1 = 0;
8308 if (jarg1) {
8309 arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
8310 if (!arg1) return 0;
8311 }
8312 arg2 = 0;
8313 if (jarg2) {
8314 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);
8315 if (!arg2) return 0;
8316 }
8317 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
8318 jresult = (jint)result;
8319 if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
8320 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2);
8321 return jresult;
8322 }
8323
8324
8325 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsfam(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3) {
8326 PLINT arg1 ;
8327 PLINT arg2 ;
8328 PLINT arg3 ;
8329
8330 (void)jenv;
8331 (void)jcls;
8332 arg1 = (PLINT)jarg1;
8333 arg2 = (PLINT)jarg2;
8334 arg3 = (PLINT)jarg3;
8335 plsfam(arg1,arg2,arg3);
8336 }
8337
8338
8339 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsfci(JNIEnv *jenv, jclass jcls, jlong jarg1) {
8340 PLUNICODE arg1 ;
8341
8342 (void)jenv;
8343 (void)jcls;
8344 arg1 = (PLUNICODE)jarg1;
8345 plsfci(arg1);
8346 }
8347
8348
8349 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsfnam(JNIEnv *jenv, jclass jcls, jstring jarg1) {
8350 char *arg1 = (char *) 0 ;
8351
8352 (void)jenv;
8353 (void)jcls;
8354 arg1 = 0;
8355 if (jarg1) {
8356 arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
8357 if (!arg1) return ;
8358 }
8359 plsfnam((char const *)arg1);
8360 if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
8361 }
8362
8363
8364 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsfont(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3) {
8365 PLINT arg1 ;
8366 PLINT arg2 ;
8367 PLINT arg3 ;
8368
8369 (void)jenv;
8370 (void)jcls;
8371 arg1 = (PLINT)jarg1;
8372 arg2 = (PLINT)jarg2;
8373 arg3 = (PLINT)jarg3;
8374 plsfont(arg1,arg2,arg3);
8375 }
8376
8377
8378 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plshades(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jdouble jarg5, jdouble jarg6, jdouble jarg7, jdouble jarg8, jdoubleArray jarg9, jdouble jarg11, jint jarg12, jdouble jarg13, jboolean jarg15, jobjectArray jarg16, jobjectArray jarg17) {
8379 PLFLT **arg1 = (PLFLT **) 0 ;
8380 PLINT arg2 ;
8381 PLINT arg3 ;
8382 defined_func arg4 ;
8383 PLFLT arg5 ;
8384 PLFLT arg6 ;
8385 PLFLT arg7 ;
8386 PLFLT arg8 ;
8387 PLFLT *arg9 = (PLFLT *) 0 ;
8388 PLINT arg10 ;
8389 PLFLT arg11 ;
8390 PLINT arg12 ;
8391 PLFLT arg13 ;
8392 fill_func arg14 ;
8393 PLBOOL arg15 ;
8394 pltr_func arg16 ;
8395 PLPointer arg17 = (PLPointer) 0 ;
8396
8397 (void)jenv;
8398 (void)jcls;
8399 {
8400 arg4 = NULL;
8401 }
8402 {
8403 arg14 = plfill;
8404 }
8405 {
8406 jdouble **adat;
8407 jobject *ai;
8408 int nx = ( *jenv )->GetArrayLength( jenv, jarg1 );
8409 int ny = -1;
8410 int i, j;
8411 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
8412 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
8413
8414 ( *jenv )->EnsureLocalCapacity( jenv, nx );
8415
8416 for ( i = 0; i < nx; i++ )
8417 {
8418 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg1, i );
8419 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
8420
8421 if ( ny == -1 )
8422 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
8423 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
8424 {
8425 printf( "Misshapen a array.\n" );
8426 for ( j = 0; j <= i; j++ )
8427 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
8428 free( adat );
8429 free( ai );
8430 return;
8431 }
8432 }
8433
8434 Xlen = nx;
8435 Ylen = ny;
8436 setup_array_2d_d( &arg1, adat, nx, ny );
8437 arg2 = nx;
8438 arg3 = ny;
8439 for ( i = 0; i < nx; i++ )
8440 {
8441 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
8442 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
8443 }
8444
8445 free( adat );
8446 free( ai );
8447 }
8448 arg5 = (PLFLT)jarg5;
8449 arg6 = (PLFLT)jarg6;
8450 arg7 = (PLFLT)jarg7;
8451 arg8 = (PLFLT)jarg8;
8452 {
8453 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg9, 0 );
8454 arg10 = ( *jenv )->GetArrayLength( jenv, jarg9 );
8455 setup_array_1d_d( &arg9, jxdata, arg10 );
8456 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg9, jxdata, 0 );
8457 }
8458 arg11 = (PLFLT)jarg11;
8459 arg12 = (PLINT)jarg12;
8460 arg13 = (PLFLT)jarg13;
8461
8462 arg15 = jarg15 ? 1 : 0;
8463
8464 {
8465 jdouble **adat;
8466 jobject *ai;
8467 int nx = ( *jenv )->GetArrayLength( jenv, jarg16 );
8468 int ny = -1;
8469 int i, j;
8470 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
8471 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
8472
8473 ( *jenv )->EnsureLocalCapacity( jenv, nx );
8474
8475 for ( i = 0; i < nx; i++ )
8476 {
8477 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg16, i );
8478 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
8479
8480 if ( ny == -1 )
8481 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
8482 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
8483 {
8484 printf( "Misshapen a array.\n" );
8485 for ( j = 0; j <= i; j++ )
8486 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
8487 free( adat );
8488 free( ai );
8489 return;
8490 }
8491 }
8492
8493 if ( !( ( nx == Xlen && ny == Ylen ) || ( nx == Xlen && ny == 1 ) ) )
8494 {
8495 printf( "Xlen =%d, nx =%d, Ylen =%d, ny =%d\n", Xlen, nx, Ylen, ny );
8496 printf( "X vector or matrix must match matrix dimensions.\n" );
8497 for ( i = 0; i < nx; i++ )
8498 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
8499 free( adat );
8500 free( ai );
8501 return;
8502 }
8503 // Store whether second dimension is unity.
8504 Alen = ny;
8505 setup_array_2d_d( &xg, adat, nx, ny );
8506 for ( i = 0; i < nx; i++ )
8507 {
8508 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
8509 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
8510 }
8511
8512 free( adat );
8513 free( ai );
8514 arg16 = pltr2;
8515 }
8516 {
8517 jdouble **adat;
8518 jobject *ai;
8519 int nx = ( *jenv )->GetArrayLength( jenv, jarg17 );
8520 int ny = -1;
8521 int i, j;
8522 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
8523 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
8524
8525 ( *jenv )->EnsureLocalCapacity( jenv, nx );
8526
8527 for ( i = 0; i < nx; i++ )
8528 {
8529 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg17, i );
8530 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
8531
8532 if ( ny == -1 )
8533 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
8534 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
8535 {
8536 printf( "Misshapen a array.\n" );
8537 for ( j = 0; j <= i; j++ )
8538 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
8539 free( adat );
8540 free( ai );
8541 return;
8542 }
8543 }
8544
8545 if ( !( ( nx == Xlen && ny == Ylen ) || ( nx == Ylen && ny == 1 && ny == Alen ) ) )
8546 {
8547 printf( "Xlen =%d, nx =%d, Ylen =%d, Alen =%d, ny =%d\n",
8548 Xlen, nx, Ylen, Alen, ny );
8549 printf( "Y vector or matrix must match matrix dimensions.\n" );
8550 for ( i = 0; i < nx; i++ )
8551 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
8552 free( adat );
8553 free( ai );
8554 return;
8555 }
8556 setup_array_2d_d( &yg, adat, nx, ny );
8557 for ( i = 0; i < nx; i++ )
8558 {
8559 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
8560 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
8561 }
8562
8563 free( adat );
8564 free( ai );
8565 cgrid = (PLcGrid2 *) malloc( sizeof ( PLcGrid2 ) );
8566 cgrid->xg = xg;
8567 cgrid->yg = yg;
8568 cgrid->nx = nx;
8569 cgrid->ny = ny;
8570 arg17 = cgrid;
8571 }
8572 plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
8573 {
8574 free( arg1[0] );
8575 free( arg1 );
8576 }
8577 {
8578 free( arg9 );
8579 }
8580 {
8581 free( xg[0] );
8582 free( xg );
8583 }
8584 {
8585 free( yg[0] );
8586 free( yg );
8587 free( cgrid );
8588 }
8589 }
8590
8591
8592 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, jdouble jarg13, jint jarg14, jdouble jarg15, jint jarg16, jdouble jarg17, jboolean jarg19, jobjectArray jarg20, jobjectArray jarg21) {
8593 PLFLT **arg1 = (PLFLT **) 0 ;
8594 PLINT arg2 ;
8595 PLINT arg3 ;
8596 defined_func arg4 ;
8597 PLFLT arg5 ;
8598 PLFLT arg6 ;
8599 PLFLT arg7 ;
8600 PLFLT arg8 ;
8601 PLFLT arg9 ;
8602 PLFLT arg10 ;
8603 PLINT arg11 ;
8604 PLFLT arg12 ;
8605 PLFLT arg13 ;
8606 PLINT arg14 ;
8607 PLFLT arg15 ;
8608 PLINT arg16 ;
8609 PLFLT arg17 ;
8610 fill_func arg18 ;
8611 PLBOOL arg19 ;
8612 pltr_func arg20 ;
8613 PLPointer arg21 = (PLPointer) 0 ;
8614
8615 (void)jenv;
8616 (void)jcls;
8617 {
8618 arg4 = NULL;
8619 }
8620 {
8621 arg18 = plfill;
8622 }
8623 {
8624 jdouble **adat;
8625 jobject *ai;
8626 int nx = ( *jenv )->GetArrayLength( jenv, jarg1 );
8627 int ny = -1;
8628 int i, j;
8629 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
8630 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
8631
8632 ( *jenv )->EnsureLocalCapacity( jenv, nx );
8633
8634 for ( i = 0; i < nx; i++ )
8635 {
8636 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg1, i );
8637 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
8638
8639 if ( ny == -1 )
8640 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
8641 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
8642 {
8643 printf( "Misshapen a array.\n" );
8644 for ( j = 0; j <= i; j++ )
8645 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
8646 free( adat );
8647 free( ai );
8648 return;
8649 }
8650 }
8651
8652 Xlen = nx;
8653 Ylen = ny;
8654 setup_array_2d_d( &arg1, adat, nx, ny );
8655 arg2 = nx;
8656 arg3 = ny;
8657 for ( i = 0; i < nx; i++ )
8658 {
8659 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
8660 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
8661 }
8662
8663 free( adat );
8664 free( ai );
8665 }
8666 arg5 = (PLFLT)jarg5;
8667 arg6 = (PLFLT)jarg6;
8668 arg7 = (PLFLT)jarg7;
8669 arg8 = (PLFLT)jarg8;
8670 arg9 = (PLFLT)jarg9;
8671 arg10 = (PLFLT)jarg10;
8672 arg11 = (PLINT)jarg11;
8673 arg12 = (PLFLT)jarg12;
8674 arg13 = (PLFLT)jarg13;
8675 arg14 = (PLINT)jarg14;
8676 arg15 = (PLFLT)jarg15;
8677 arg16 = (PLINT)jarg16;
8678 arg17 = (PLFLT)jarg17;
8679
8680 arg19 = jarg19 ? 1 : 0;
8681
8682 {
8683 jdouble **adat;
8684 jobject *ai;
8685 int nx = ( *jenv )->GetArrayLength( jenv, jarg20 );
8686 int ny = -1;
8687 int i, j;
8688 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
8689 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
8690
8691 ( *jenv )->EnsureLocalCapacity( jenv, nx );
8692
8693 for ( i = 0; i < nx; i++ )
8694 {
8695 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg20, i );
8696 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
8697
8698 if ( ny == -1 )
8699 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
8700 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
8701 {
8702 printf( "Misshapen a array.\n" );
8703 for ( j = 0; j <= i; j++ )
8704 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
8705 free( adat );
8706 free( ai );
8707 return;
8708 }
8709 }
8710
8711 if ( !( ( nx == Xlen && ny == Ylen ) || ( nx == Xlen && ny == 1 ) ) )
8712 {
8713 printf( "Xlen =%d, nx =%d, Ylen =%d, ny =%d\n", Xlen, nx, Ylen, ny );
8714 printf( "X vector or matrix must match matrix dimensions.\n" );
8715 for ( i = 0; i < nx; i++ )
8716 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
8717 free( adat );
8718 free( ai );
8719 return;
8720 }
8721 // Store whether second dimension is unity.
8722 Alen = ny;
8723 setup_array_2d_d( &xg, adat, nx, ny );
8724 for ( i = 0; i < nx; i++ )
8725 {
8726 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
8727 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
8728 }
8729
8730 free( adat );
8731 free( ai );
8732 arg20 = pltr2;
8733 }
8734 {
8735 jdouble **adat;
8736 jobject *ai;
8737 int nx = ( *jenv )->GetArrayLength( jenv, jarg21 );
8738 int ny = -1;
8739 int i, j;
8740 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
8741 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
8742
8743 ( *jenv )->EnsureLocalCapacity( jenv, nx );
8744
8745 for ( i = 0; i < nx; i++ )
8746 {
8747 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg21, i );
8748 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
8749
8750 if ( ny == -1 )
8751 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
8752 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
8753 {
8754 printf( "Misshapen a array.\n" );
8755 for ( j = 0; j <= i; j++ )
8756 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
8757 free( adat );
8758 free( ai );
8759 return;
8760 }
8761 }
8762
8763 if ( !( ( nx == Xlen && ny == Ylen ) || ( nx == Ylen && ny == 1 && ny == Alen ) ) )
8764 {
8765 printf( "Xlen =%d, nx =%d, Ylen =%d, Alen =%d, ny =%d\n",
8766 Xlen, nx, Ylen, Alen, ny );
8767 printf( "Y vector or matrix must match matrix dimensions.\n" );
8768 for ( i = 0; i < nx; i++ )
8769 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
8770 free( adat );
8771 free( ai );
8772 return;
8773 }
8774 setup_array_2d_d( &yg, adat, nx, ny );
8775 for ( i = 0; i < nx; i++ )
8776 {
8777 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
8778 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
8779 }
8780
8781 free( adat );
8782 free( ai );
8783 cgrid = (PLcGrid2 *) malloc( sizeof ( PLcGrid2 ) );
8784 cgrid->xg = xg;
8785 cgrid->yg = yg;
8786 cgrid->nx = nx;
8787 cgrid->ny = ny;
8788 arg21 = cgrid;
8789 }
8790 plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
8791 {
8792 free( arg1[0] );
8793 free( arg1 );
8794 }
8795 {
8796 free( xg[0] );
8797 free( xg );
8798 }
8799 {
8800 free( yg[0] );
8801 free( yg );
8802 free( cgrid );
8803 }
8804 }
8805
8806
8807 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plslabelfunc(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) {
8808 label_func arg1 ;
8809 PLPointer arg2 = (PLPointer) 0 ;
8810
8811 (void)jenv;
8812 (void)jcls;
8813 {
8814 jobject obj = jarg1;
8815
8816 // Delete any old references
8817 if ( labelClass != 0 )
8818 {
8819 ( *jenv )->DeleteGlobalRef( jenv, labelClass );
8820 labelClass = 0;
8821 }
8822 // Need a reference to this object to ensure it is
8823 // valid when we reach the callback
8824 if ( obj != NULL )
8825 {
8826 labelClass = ( *jenv )->NewGlobalRef( jenv, obj );
8827 }
8828 if ( labelClass != 0 )
8829 {
8830 arg1 = label_java;
8831 }
8832 else
8833 {
8834 arg1 = NULL;
8835 }
8836 }
8837 {
8838 arg2 = NULL;
8839 }
8840 plslabelfunc(arg1,arg2);
8841 }
8842
8843
8844 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsmaj(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2) {
8845 PLFLT arg1 ;
8846 PLFLT arg2 ;
8847
8848 (void)jenv;
8849 (void)jcls;
8850 arg1 = (PLFLT)jarg1;
8851 arg2 = (PLFLT)jarg2;
8852 plsmaj(arg1,arg2);
8853 }
8854
8855
8856 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsmin(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2) {
8857 PLFLT arg1 ;
8858 PLFLT arg2 ;
8859
8860 (void)jenv;
8861 (void)jcls;
8862 arg1 = (PLFLT)jarg1;
8863 arg2 = (PLFLT)jarg2;
8864 plsmin(arg1,arg2);
8865 }
8866
8867
8868 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsori(JNIEnv *jenv, jclass jcls, jint jarg1) {
8869 PLINT arg1 ;
8870
8871 (void)jenv;
8872 (void)jcls;
8873 arg1 = (PLINT)jarg1;
8874 plsori(arg1);
8875 }
8876
8877
8878 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plspage(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6) {
8879 PLFLT arg1 ;
8880 PLFLT arg2 ;
8881 PLINT arg3 ;
8882 PLINT arg4 ;
8883 PLINT arg5 ;
8884 PLINT arg6 ;
8885
8886 (void)jenv;
8887 (void)jcls;
8888 arg1 = (PLFLT)jarg1;
8889 arg2 = (PLFLT)jarg2;
8890 arg3 = (PLINT)jarg3;
8891 arg4 = (PLINT)jarg4;
8892 arg5 = (PLINT)jarg5;
8893 arg6 = (PLINT)jarg6;
8894 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
8895 }
8896
8897
8898 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plspal0(JNIEnv *jenv, jclass jcls, jstring jarg1) {
8899 char *arg1 = (char *) 0 ;
8900
8901 (void)jenv;
8902 (void)jcls;
8903 arg1 = 0;
8904 if (jarg1) {
8905 arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
8906 if (!arg1) return ;
8907 }
8908 plspal0((char const *)arg1);
8909 if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
8910 }
8911
8912
8913 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plspal1(JNIEnv *jenv, jclass jcls, jstring jarg1, jboolean jarg2) {
8914 char *arg1 = (char *) 0 ;
8915 PLBOOL arg2 ;
8916
8917 (void)jenv;
8918 (void)jcls;
8919 arg1 = 0;
8920 if (jarg1) {
8921 arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
8922 if (!arg1) return ;
8923 }
8924
8925 arg2 = jarg2 ? 1 : 0;
8926
8927 plspal1((char const *)arg1,arg2);
8928 if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
8929 }
8930
8931
8932 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plspause(JNIEnv *jenv, jclass jcls, jboolean jarg1) {
8933 PLBOOL arg1 ;
8934
8935 (void)jenv;
8936 (void)jcls;
8937
8938 arg1 = jarg1 ? 1 : 0;
8939
8940 plspause(arg1);
8941 }
8942
8943
8944 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsstrm(JNIEnv *jenv, jclass jcls, jint jarg1) {
8945 PLINT arg1 ;
8946
8947 (void)jenv;
8948 (void)jcls;
8949 arg1 = (PLINT)jarg1;
8950 plsstrm(arg1);
8951 }
8952
8953
8954 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plssub(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {
8955 PLINT arg1 ;
8956 PLINT arg2 ;
8957
8958 (void)jenv;
8959 (void)jcls;
8960 arg1 = (PLINT)jarg1;
8961 arg2 = (PLINT)jarg2;
8962 plssub(arg1,arg2);
8963 }
8964
8965
8966 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plssym(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2) {
8967 PLFLT arg1 ;
8968 PLFLT arg2 ;
8969
8970 (void)jenv;
8971 (void)jcls;
8972 arg1 = (PLFLT)jarg1;
8973 arg2 = (PLFLT)jarg2;
8974 plssym(arg1,arg2);
8975 }
8976
8977
8978 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstar(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {
8979 PLINT arg1 ;
8980 PLINT arg2 ;
8981
8982 (void)jenv;
8983 (void)jcls;
8984 arg1 = (PLINT)jarg1;
8985 arg2 = (PLINT)jarg2;
8986 plstar(arg1,arg2);
8987 }
8988
8989
8990 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstart(JNIEnv *jenv, jclass jcls, jstring jarg1, jint jarg2, jint jarg3) {
8991 char *arg1 = (char *) 0 ;
8992 PLINT arg2 ;
8993 PLINT arg3 ;
8994
8995 (void)jenv;
8996 (void)jcls;
8997 arg1 = 0;
8998 if (jarg1) {
8999 arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
9000 if (!arg1) return ;
9001 }
9002 arg2 = (PLINT)jarg2;
9003 arg3 = (PLINT)jarg3;
9004 plstart((char const *)arg1,arg2,arg3);
9005 if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
9006 }
9007
9008
9009 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstransform(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) {
9010 ct_func arg1 ;
9011 PLPointer arg2 = (PLPointer) 0 ;
9012
9013 (void)jenv;
9014 (void)jcls;
9015 {
9016 jobject obj = jarg1;
9017
9018 // Delete any old references
9019 if ( ctClass != 0 )
9020 {
9021 ( *jenv )->DeleteGlobalRef( jenv, ctClass );
9022 ctClass = 0;
9023 }
9024 // Need a reference to this object to ensure it is
9025 // valid when we reach the callback
9026 if ( obj != NULL )
9027 {
9028 ctClass = ( *jenv )->NewGlobalRef( jenv, obj );
9029 }
9030 if ( ctClass != 0 )
9031 {
9032 arg1 = ct_java;
9033 }
9034 else
9035 {
9036 arg1 = NULL;
9037 }
9038 }
9039 {
9040 arg2 = NULL;
9041 }
9042 plstransform(arg1,arg2);
9043 }
9044
9045
9046 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstring(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jstring jarg4) {
9047 PLINT arg1 ;
9048 PLFLT *arg2 = (PLFLT *) 0 ;
9049 PLFLT *arg3 = (PLFLT *) 0 ;
9050 char *arg4 = (char *) 0 ;
9051
9052 (void)jenv;
9053 (void)jcls;
9054 {
9055 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
9056 arg1 = ( *jenv )->GetArrayLength( jenv, jarg1 );
9057 Alen = arg1;
9058 setup_array_1d_d( &arg2, jxdata, Alen );
9059 // Could find no easy way to do this as part of freearg so I modified
9060 // the previous function so it ALWAYS mallocs and copies so that
9061 // the java array can be released immediately.
9062 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
9063 }
9064 {
9065 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
9066 if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
9067 {
9068 printf( "Vectors must be same length.\n" );
9069 return;
9070 }
9071 setup_array_1d_d( &arg3, jydata, Alen );
9072 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
9073 }
9074 arg4 = 0;
9075 if (jarg4) {
9076 arg4 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg4, 0);
9077 if (!arg4) return ;
9078 }
9079 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
9080 {
9081 free( arg2 );
9082 }
9083 {
9084 free( arg3 );
9085 }
9086 if (arg4) (*jenv)->ReleaseStringUTFChars(jenv, jarg4, (const char *)arg4);
9087 }
9088
9089
9090 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstring3(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jdoubleArray jarg4, jstring jarg5) {
9091 PLINT arg1 ;
9092 PLFLT *arg2 = (PLFLT *) 0 ;
9093 PLFLT *arg3 = (PLFLT *) 0 ;
9094 PLFLT *arg4 = (PLFLT *) 0 ;
9095 char *arg5 = (char *) 0 ;
9096
9097 (void)jenv;
9098 (void)jcls;
9099 {
9100 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
9101 arg1 = ( *jenv )->GetArrayLength( jenv, jarg1 );
9102 Alen = arg1;
9103 setup_array_1d_d( &arg2, jxdata, Alen );
9104 // Could find no easy way to do this as part of freearg so I modified
9105 // the previous function so it ALWAYS mallocs and copies so that
9106 // the java array can be released immediately.
9107 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
9108 }
9109 {
9110 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
9111 if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
9112 {
9113 printf( "Vectors must be same length.\n" );
9114 return;
9115 }
9116 setup_array_1d_d( &arg3, jydata, Alen );
9117 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
9118 }
9119 {
9120 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg4, 0 );
9121 if ( ( *jenv )->GetArrayLength( jenv, jarg4 ) != Alen )
9122 {
9123 printf( "Vectors must be same length.\n" );
9124 return;
9125 }
9126 setup_array_1d_d( &arg4, jydata, Alen );
9127 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );
9128 }
9129 arg5 = 0;
9130 if (jarg5) {
9131 arg5 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg5, 0);
9132 if (!arg5) return ;
9133 }
9134 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
9135 {
9136 free( arg2 );
9137 }
9138 {
9139 free( arg3 );
9140 }
9141 {
9142 free( arg4 );
9143 }
9144 if (arg5) (*jenv)->ReleaseStringUTFChars(jenv, jarg5, (const char *)arg5);
9145 }
9146
9147
9148 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstripa(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jdouble jarg3, jdouble jarg4) {
9149 PLINT arg1 ;
9150 PLINT arg2 ;
9151 PLFLT arg3 ;
9152 PLFLT arg4 ;
9153
9154 (void)jenv;
9155 (void)jcls;
9156 arg1 = (PLINT)jarg1;
9157 arg2 = (PLINT)jarg2;
9158 arg3 = (PLFLT)jarg3;
9159 arg4 = (PLFLT)jarg4;
9160 plstripa(arg1,arg2,arg3,arg4);
9161 }
9162
9163
9164 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) {
9165 PLINT *arg1 = (PLINT *) 0 ;
9166 char *arg2 = (char *) 0 ;
9167 char *arg3 = (char *) 0 ;
9168 PLFLT arg4 ;
9169 PLFLT arg5 ;
9170 PLFLT arg6 ;
9171 PLFLT arg7 ;
9172 PLFLT arg8 ;
9173 PLFLT arg9 ;
9174 PLFLT arg10 ;
9175 PLBOOL arg11 ;
9176 PLBOOL arg12 ;
9177 PLINT arg13 ;
9178 PLINT arg14 ;
9179 PLINT *arg15 = (PLINT *) 0 ;
9180 PLINT *arg16 = (PLINT *) 0 ;
9181 char **arg17 ;
9182 char *arg18 = (char *) 0 ;
9183 char *arg19 = (char *) 0 ;
9184 char *arg20 = (char *) 0 ;
9185 PLINT temp1 ;
9186
9187 (void)jenv;
9188 (void)jcls;
9189 {
9190 if (!jarg1) {
9191 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
9192 return ;
9193 }
9194 if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {
9195 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
9196 return ;
9197 }
9198 temp1 = (PLINT)0;
9199 arg1 = &temp1;
9200 }
9201 arg2 = 0;
9202 if (jarg2) {
9203 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);
9204 if (!arg2) return ;
9205 }
9206 arg3 = 0;
9207 if (jarg3) {
9208 arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0);
9209 if (!arg3) return ;
9210 }
9211 arg4 = (PLFLT)jarg4;
9212 arg5 = (PLFLT)jarg5;
9213 arg6 = (PLFLT)jarg6;
9214 arg7 = (PLFLT)jarg7;
9215 arg8 = (PLFLT)jarg8;
9216 arg9 = (PLFLT)jarg9;
9217 arg10 = (PLFLT)jarg10;
9218
9219 arg11 = jarg11 ? 1 : 0;
9220
9221
9222 arg12 = jarg12 ? 1 : 0;
9223
9224 arg13 = (PLINT)jarg13;
9225 arg14 = (PLINT)jarg14;
9226 {
9227 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg15, 0 );
9228 Alen = ( *jenv )->GetArrayLength( jenv, jarg15 );
9229 setup_array_1d_i( &arg15, jydata, Alen );
9230 ( *jenv )->ReleaseIntArrayElements( jenv, jarg15, jydata, 0 );
9231 }
9232 {
9233 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg16, 0 );
9234 if ( ( *jenv )->GetArrayLength( jenv, jarg16 ) != Alen )
9235 {
9236 printf( "Vectors must be same length.\n" );
9237 return;
9238 }
9239 setup_array_1d_i( &arg16, jydata, Alen );
9240 ( *jenv )->ReleaseIntArrayElements( jenv, jarg16, jydata, 0 );
9241 }
9242 {
9243 int i = 0;
9244 int size = ( *jenv )->GetArrayLength( jenv, jarg17 );
9245 if ( size != 4 )
9246 {
9247 printf( "legline must be an array of length 4\n" );
9248 return;
9249 }
9250 arg17 = (char **) malloc( 4 * sizeof ( char * ) );
9251 // make a copy of each string
9252 for ( i = 0; i < 4; i++ )
9253 {
9254 jstring j_string = (jstring) ( *jenv )->GetObjectArrayElement( jenv, jarg17, i );
9255 const char * c_string = (char *) ( *jenv )->GetStringUTFChars( jenv, j_string, 0 );
9256 arg17[i] = malloc( ( strlen( c_string ) + 1 ) * sizeof ( const char * ) );
9257 strcpy( arg17[i], c_string );
9258 ( *jenv )->ReleaseStringUTFChars( jenv, j_string, c_string );
9259 ( *jenv )->DeleteLocalRef( jenv, j_string );
9260 }
9261 }
9262 arg18 = 0;
9263 if (jarg18) {
9264 arg18 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg18, 0);
9265 if (!arg18) return ;
9266 }
9267 arg19 = 0;
9268 if (jarg19) {
9269 arg19 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg19, 0);
9270 if (!arg19) return ;
9271 }
9272 arg20 = 0;
9273 if (jarg20) {
9274 arg20 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg20, 0);
9275 if (!arg20) return ;
9276 }
9277 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);
9278 {
9279 jint jvalue = (jint)temp1;
9280 (*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);
9281 }
9282
9283 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2);
9284 if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3);
9285 {
9286 free( arg15 );
9287 }
9288 {
9289 free( arg16 );
9290 }
9291 {
9292 int i;
9293 for ( i = 0; i < 4; i++ )
9294 free( arg17[i] );
9295 free( arg17 );
9296 }
9297 if (arg18) (*jenv)->ReleaseStringUTFChars(jenv, jarg18, (const char *)arg18);
9298 if (arg19) (*jenv)->ReleaseStringUTFChars(jenv, jarg19, (const char *)arg19);
9299 if (arg20) (*jenv)->ReleaseStringUTFChars(jenv, jarg20, (const char *)arg20);
9300 }
9301
9302
9303 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstripd(JNIEnv *jenv, jclass jcls, jint jarg1) {
9304 PLINT arg1 ;
9305
9306 (void)jenv;
9307 (void)jcls;
9308 arg1 = (PLINT)jarg1;
9309 plstripd(arg1);
9310 }
9311
9312
9313 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstyl(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg3) {
9314 PLINT arg1 ;
9315 PLINT *arg2 = (PLINT *) 0 ;
9316 PLINT *arg3 = (PLINT *) 0 ;
9317
9318 (void)jenv;
9319 (void)jcls;
9320 {
9321 jint *jxdata = ( *jenv )->GetIntArrayElements( jenv, jarg1, 0 );
9322 arg1 = ( *jenv )->GetArrayLength( jenv, jarg1 );
9323 Alen = arg1;
9324 setup_array_1d_i( &arg2, jxdata, Alen );
9325 // Could find no easy way to do this as part of freearg so I modified
9326 // the previous function so it ALWAYS mallocs and copies so that
9327 // the java array can be released immediately.
9328 ( *jenv )->ReleaseIntArrayElements( jenv, jarg1, jxdata, 0 );
9329 }
9330 {
9331 jint *jydata = ( *jenv )->GetIntArrayElements( jenv, jarg3, 0 );
9332 if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
9333 {
9334 printf( "Vectors must be same length.\n" );
9335 return;
9336 }
9337 setup_array_1d_i( &arg3, jydata, Alen );
9338 ( *jenv )->ReleaseIntArrayElements( jenv, jarg3, jydata, 0 );
9339 }
9340 plstyl(arg1,(int const *)arg2,(int const *)arg3);
9341 {
9342 free( arg2 );
9343 }
9344 {
9345 free( arg3 );
9346 }
9347 }
9348
9349
9350 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsvect(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jboolean jarg4) {
9351 PLFLT *arg1 = (PLFLT *) 0 ;
9352 PLFLT *arg2 = (PLFLT *) 0 ;
9353 PLINT arg3 ;
9354 PLBOOL arg4 ;
9355
9356 (void)jenv;
9357 (void)jcls;
9358 {
9359 if ( jarg1 != NULL )
9360 {
9361 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
9362 Alen = ( *jenv )->GetArrayLength( jenv, jarg1 );
9363 setup_array_1d_d( &arg1, jxdata, Alen );
9364 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
9365 }
9366 else
9367 {
9368 arg1 = NULL;
9369 Alen = 0;
9370 }
9371 }
9372 {
9373 if ( jarg2 != NULL )
9374 {
9375 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg2, 0 );
9376 arg3 = ( *jenv )->GetArrayLength( jenv, jarg2 );
9377 if ( ( *jenv )->GetArrayLength( jenv, jarg2 ) != Alen )
9378 {
9379 printf( "Vectors must be same length.\n" );
9380 return;
9381 }
9382 setup_array_1d_d( &arg2, jydata, Alen );
9383 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );
9384 }
9385 else
9386 {
9387 arg2 = NULL;
9388 arg3 = 0;
9389 }
9390 }
9391
9392 arg4 = jarg4 ? 1 : 0;
9393
9394 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
9395 {
9396 if ( arg1 != NULL )
9397 free( arg1 );
9398 }
9399 {
9400 if ( arg2 != NULL )
9401 free( arg2 );
9402 }
9403 }
9404
9405
9406 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsvpa(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4) {
9407 PLFLT arg1 ;
9408 PLFLT arg2 ;
9409 PLFLT arg3 ;
9410 PLFLT arg4 ;
9411
9412 (void)jenv;
9413 (void)jcls;
9414 arg1 = (PLFLT)jarg1;
9415 arg2 = (PLFLT)jarg2;
9416 arg3 = (PLFLT)jarg3;
9417 arg4 = (PLFLT)jarg4;
9418 plsvpa(arg1,arg2,arg3,arg4);
9419 }
9420
9421
9422 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsxax(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {
9423 PLINT arg1 ;
9424 PLINT arg2 ;
9425
9426 (void)jenv;
9427 (void)jcls;
9428 arg1 = (PLINT)jarg1;
9429 arg2 = (PLINT)jarg2;
9430 plsxax(arg1,arg2);
9431 }
9432
9433
9434 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsyax(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {
9435 PLINT arg1 ;
9436 PLINT arg2 ;
9437
9438 (void)jenv;
9439 (void)jcls;
9440 arg1 = (PLINT)jarg1;
9441 arg2 = (PLINT)jarg2;
9442 plsyax(arg1,arg2);
9443 }
9444
9445
9446 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsym(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jint jarg4) {
9447 PLINT arg1 ;
9448 PLFLT *arg2 = (PLFLT *) 0 ;
9449 PLFLT *arg3 = (PLFLT *) 0 ;
9450 PLINT arg4 ;
9451
9452 (void)jenv;
9453 (void)jcls;
9454 {
9455 jdouble *jxdata = ( *jenv )->GetDoubleArrayElements( jenv, jarg1, 0 );
9456 arg1 = ( *jenv )->GetArrayLength( jenv, jarg1 );
9457 Alen = arg1;
9458 setup_array_1d_d( &arg2, jxdata, Alen );
9459 // Could find no easy way to do this as part of freearg so I modified
9460 // the previous function so it ALWAYS mallocs and copies so that
9461 // the java array can be released immediately.
9462 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );
9463 }
9464 {
9465 jdouble *jydata = ( *jenv )->GetDoubleArrayElements( jenv, jarg3, 0 );
9466 if ( ( *jenv )->GetArrayLength( jenv, jarg3 ) != Alen )
9467 {
9468 printf( "Vectors must be same length.\n" );
9469 return;
9470 }
9471 setup_array_1d_d( &arg3, jydata, Alen );
9472 ( *jenv )->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );
9473 }
9474 arg4 = (PLINT)jarg4;
9475 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
9476 {
9477 free( arg2 );
9478 }
9479 {
9480 free( arg3 );
9481 }
9482 }
9483
9484
9485 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plszax(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {
9486 PLINT arg1 ;
9487 PLINT arg2 ;
9488
9489 (void)jenv;
9490 (void)jcls;
9491 arg1 = (PLINT)jarg1;
9492 arg2 = (PLINT)jarg2;
9493 plszax(arg1,arg2);
9494 }
9495
9496
9497 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pltext(JNIEnv *jenv, jclass jcls) {
9498 (void)jenv;
9499 (void)jcls;
9500 pltext();
9501 }
9502
9503
9504 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pltimefmt(JNIEnv *jenv, jclass jcls, jstring jarg1) {
9505 char *arg1 = (char *) 0 ;
9506
9507 (void)jenv;
9508 (void)jcls;
9509 arg1 = 0;
9510 if (jarg1) {
9511 arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
9512 if (!arg1) return ;
9513 }
9514 pltimefmt((char const *)arg1);
9515 if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
9516 }
9517
9518
9519 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plvasp(JNIEnv *jenv, jclass jcls, jdouble jarg1) {
9520 PLFLT arg1 ;
9521
9522 (void)jenv;
9523 (void)jcls;
9524 arg1 = (PLFLT)jarg1;
9525 plvasp(arg1);
9526 }
9527
9528
9529 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plvect(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jobjectArray jarg2, jdouble jarg5, jobjectArray jarg6, jobjectArray jarg7) {
9530 PLFLT **arg1 = (PLFLT **) 0 ;
9531 PLFLT **arg2 = (PLFLT **) 0 ;
9532 PLINT arg3 ;
9533 PLINT arg4 ;
9534 PLFLT arg5 ;
9535 pltr_func arg6 ;
9536 PLPointer arg7 = (PLPointer) 0 ;
9537
9538 (void)jenv;
9539 (void)jcls;
9540 {
9541 jdouble **adat;
9542 jobject *ai;
9543 int nx = ( *jenv )->GetArrayLength( jenv, jarg1 );
9544 int ny = -1;
9545 int i, j;
9546 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
9547 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
9548
9549 ( *jenv )->EnsureLocalCapacity( jenv, nx );
9550
9551 for ( i = 0; i < nx; i++ )
9552 {
9553 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg1, i );
9554 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
9555
9556 if ( ny == -1 )
9557 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
9558 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
9559 {
9560 printf( "Misshapen a array.\n" );
9561 for ( j = 0; j <= i; j++ )
9562 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
9563 free( adat );
9564 free( ai );
9565 return;
9566 }
9567 }
9568
9569 Xlen = nx;
9570 Ylen = ny;
9571 setup_array_2d_d( &arg1, adat, nx, ny );
9572 for ( i = 0; i < nx; i++ )
9573 {
9574 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
9575 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
9576 }
9577
9578 free( adat );
9579 free( ai );
9580 }
9581 {
9582 jdouble **adat;
9583 jobject *ai;
9584 int nx = ( *jenv )->GetArrayLength( jenv, jarg2 );
9585 int ny = -1;
9586 int i, j;
9587 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
9588 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
9589
9590 ( *jenv )->EnsureLocalCapacity( jenv, nx );
9591
9592 for ( i = 0; i < nx; i++ )
9593 {
9594 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg2, i );
9595 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
9596
9597 if ( ny == -1 )
9598 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
9599 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
9600 {
9601 printf( "Misshapen a array.\n" );
9602 for ( j = 0; j <= i; j++ )
9603 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
9604 free( adat );
9605 free( ai );
9606 return;
9607 }
9608 }
9609
9610 if ( nx != Xlen || ny != Ylen )
9611 {
9612 printf( "Vectors must match matrix.\n" );
9613 for ( i = 0; i < nx; i++ )
9614 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
9615 free( adat );
9616 free( ai );
9617 return;
9618 }
9619 setup_array_2d_d( &arg2, adat, nx, ny );
9620 arg3 = nx;
9621 arg4 = ny;
9622 for ( i = 0; i < nx; i++ )
9623 {
9624 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
9625 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
9626 }
9627
9628
9629 free( adat );
9630 free( ai );
9631 }
9632 arg5 = (PLFLT)jarg5;
9633 {
9634 jdouble **adat;
9635 jobject *ai;
9636 int nx = ( *jenv )->GetArrayLength( jenv, jarg6 );
9637 int ny = -1;
9638 int i, j;
9639 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
9640 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
9641
9642 ( *jenv )->EnsureLocalCapacity( jenv, nx );
9643
9644 for ( i = 0; i < nx; i++ )
9645 {
9646 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg6, i );
9647 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
9648
9649 if ( ny == -1 )
9650 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
9651 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
9652 {
9653 printf( "Misshapen a array.\n" );
9654 for ( j = 0; j <= i; j++ )
9655 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
9656 free( adat );
9657 free( ai );
9658 return;
9659 }
9660 }
9661
9662 if ( !( ( nx == Xlen && ny == Ylen ) || ( nx == Xlen && ny == 1 ) ) )
9663 {
9664 printf( "Xlen =%d, nx =%d, Ylen =%d, ny =%d\n", Xlen, nx, Ylen, ny );
9665 printf( "X vector or matrix must match matrix dimensions.\n" );
9666 for ( i = 0; i < nx; i++ )
9667 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
9668 free( adat );
9669 free( ai );
9670 return;
9671 }
9672 // Store whether second dimension is unity.
9673 Alen = ny;
9674 setup_array_2d_d( &xg, adat, nx, ny );
9675 for ( i = 0; i < nx; i++ )
9676 {
9677 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
9678 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
9679 }
9680
9681 free( adat );
9682 free( ai );
9683 arg6 = pltr2;
9684 }
9685 {
9686 jdouble **adat;
9687 jobject *ai;
9688 int nx = ( *jenv )->GetArrayLength( jenv, jarg7 );
9689 int ny = -1;
9690 int i, j;
9691 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
9692 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
9693
9694 ( *jenv )->EnsureLocalCapacity( jenv, nx );
9695
9696 for ( i = 0; i < nx; i++ )
9697 {
9698 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg7, i );
9699 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
9700
9701 if ( ny == -1 )
9702 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
9703 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
9704 {
9705 printf( "Misshapen a array.\n" );
9706 for ( j = 0; j <= i; j++ )
9707 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
9708 free( adat );
9709 free( ai );
9710 return;
9711 }
9712 }
9713
9714 if ( !( ( nx == Xlen && ny == Ylen ) || ( nx == Ylen && ny == 1 && ny == Alen ) ) )
9715 {
9716 printf( "Xlen =%d, nx =%d, Ylen =%d, Alen =%d, ny =%d\n",
9717 Xlen, nx, Ylen, Alen, ny );
9718 printf( "Y vector or matrix must match matrix dimensions.\n" );
9719 for ( i = 0; i < nx; i++ )
9720 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
9721 free( adat );
9722 free( ai );
9723 return;
9724 }
9725 setup_array_2d_d( &yg, adat, nx, ny );
9726 for ( i = 0; i < nx; i++ )
9727 {
9728 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
9729 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
9730 }
9731
9732 free( adat );
9733 free( ai );
9734 cgrid = (PLcGrid2 *) malloc( sizeof ( PLcGrid2 ) );
9735 cgrid->xg = xg;
9736 cgrid->yg = yg;
9737 cgrid->nx = nx;
9738 cgrid->ny = ny;
9739 arg7 = cgrid;
9740 }
9741 plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
9742 {
9743 free( arg1[0] );
9744 free( arg1 );
9745 }
9746 {
9747 free( arg2[0] );
9748 free( arg2 );
9749 }
9750 {
9751 free( xg[0] );
9752 free( xg );
9753 }
9754 {
9755 free( yg[0] );
9756 free( yg );
9757 free( cgrid );
9758 }
9759 }
9760
9761
9762 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plvpas(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4, jdouble jarg5) {
9763 PLFLT arg1 ;
9764 PLFLT arg2 ;
9765 PLFLT arg3 ;
9766 PLFLT arg4 ;
9767 PLFLT arg5 ;
9768
9769 (void)jenv;
9770 (void)jcls;
9771 arg1 = (PLFLT)jarg1;
9772 arg2 = (PLFLT)jarg2;
9773 arg3 = (PLFLT)jarg3;
9774 arg4 = (PLFLT)jarg4;
9775 arg5 = (PLFLT)jarg5;
9776 plvpas(arg1,arg2,arg3,arg4,arg5);
9777 }
9778
9779
9780 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plvpor(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4) {
9781 PLFLT arg1 ;
9782 PLFLT arg2 ;
9783 PLFLT arg3 ;
9784 PLFLT arg4 ;
9785
9786 (void)jenv;
9787 (void)jcls;
9788 arg1 = (PLFLT)jarg1;
9789 arg2 = (PLFLT)jarg2;
9790 arg3 = (PLFLT)jarg3;
9791 arg4 = (PLFLT)jarg4;
9792 plvpor(arg1,arg2,arg3,arg4);
9793 }
9794
9795
9796 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plvsta(JNIEnv *jenv, jclass jcls) {
9797 (void)jenv;
9798 (void)jcls;
9799 plvsta();
9800 }
9801
9802
9803 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) {
9804 PLFLT arg1 ;
9805 PLFLT arg2 ;
9806 PLFLT arg3 ;
9807 PLFLT arg4 ;
9808 PLFLT arg5 ;
9809 PLFLT arg6 ;
9810 PLFLT arg7 ;
9811 PLFLT arg8 ;
9812 PLFLT arg9 ;
9813 PLFLT arg10 ;
9814 PLFLT arg11 ;
9815
9816 (void)jenv;
9817 (void)jcls;
9818 arg1 = (PLFLT)jarg1;
9819 arg2 = (PLFLT)jarg2;
9820 arg3 = (PLFLT)jarg3;
9821 arg4 = (PLFLT)jarg4;
9822 arg5 = (PLFLT)jarg5;
9823 arg6 = (PLFLT)jarg6;
9824 arg7 = (PLFLT)jarg7;
9825 arg8 = (PLFLT)jarg8;
9826 arg9 = (PLFLT)jarg9;
9827 arg10 = (PLFLT)jarg10;
9828 arg11 = (PLFLT)jarg11;
9829 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
9830 }
9831
9832
9833 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plwidth(JNIEnv *jenv, jclass jcls, jint jarg1) {
9834 PLINT arg1 ;
9835
9836 (void)jenv;
9837 (void)jcls;
9838 arg1 = (PLINT)jarg1;
9839 plwidth(arg1);
9840 }
9841
9842
9843 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plwind(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4) {
9844 PLFLT arg1 ;
9845 PLFLT arg2 ;
9846 PLFLT arg3 ;
9847 PLFLT arg4 ;
9848
9849 (void)jenv;
9850 (void)jcls;
9851 arg1 = (PLFLT)jarg1;
9852 arg2 = (PLFLT)jarg2;
9853 arg3 = (PLFLT)jarg3;
9854 arg4 = (PLFLT)jarg4;
9855 plwind(arg1,arg2,arg3,arg4);
9856 }
9857
9858
9859 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plxormod(JNIEnv *jenv, jclass jcls, jboolean jarg1,
9860 jbooleanArray
9861 jarg2) {
9862 PLBOOL arg1 ;
9863 PLBOOL *arg2 = (PLBOOL *) 0 ;
9864 PLBOOL temp2 ;
9865
9866 (void)jenv;
9867 (void)jcls;
9868
9869 arg1 = jarg1 ? 1 : 0;
9870
9871 {
9872 if ( !jarg2 )
9873 {
9874 SWIG_JavaThrowException( jenv, SWIG_JavaNullPointerException, "array null" );
9875 return ;
9876 }
9877 if ( (*jenv)->GetArrayLength(jenv, jarg2) == 0 )
9878 {
9879 SWIG_JavaThrowException( jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element" );
9880 return ;
9881 }
9882 arg2 = &temp2;
9883 }
9884 plxormod(arg1,arg2);
9885 {
9886 jboolean jvalue = (jboolean) temp2;
9887 (*jenv)->SetBooleanArrayRegion(jenv, jarg2, 0, 1, &jvalue);
9888 }
9889
9890 }
9891
9892
9893 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plmap(JNIEnv *jenv, jclass jcls, jobject jarg1, jstring jarg2, jdouble jarg3, jdouble jarg4, jdouble jarg5, jdouble jarg6) {
9894 mapform_func arg1 ;
9895 char *arg2 = (char *) 0 ;
9896 PLFLT arg3 ;
9897 PLFLT arg4 ;
9898 PLFLT arg5 ;
9899 PLFLT arg6 ;
9900
9901 (void)jenv;
9902 (void)jcls;
9903 {
9904 jobject obj = jarg1;
9905 if ( obj != NULL )
9906 {
9907 jclass cls = ( *jenv )->GetObjectClass( jenv, obj );
9908 mapformID = ( *jenv )->GetMethodID( jenv, cls, "mapform", "([D[D)V" );
9909 mapformClass = obj;
9910 cbenvMapform = jenv;
9911 arg1 = mapform_java;
9912 }
9913 else
9914 {
9915 arg1 = NULL;
9916 }
9917 }
9918 arg2 = 0;
9919 if (jarg2) {
9920 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);
9921 if (!arg2) return ;
9922 }
9923 arg3 = (PLFLT)jarg3;
9924 arg4 = (PLFLT)jarg4;
9925 arg5 = (PLFLT)jarg5;
9926 arg6 = (PLFLT)jarg6;
9927 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
9928 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2);
9929 }
9930
9931
9932 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) {
9933 mapform_func arg1 ;
9934 PLFLT arg2 ;
9935 PLFLT arg3 ;
9936 PLFLT arg4 ;
9937 PLFLT arg5 ;
9938 PLFLT arg6 ;
9939 PLFLT arg7 ;
9940
9941 (void)jenv;
9942 (void)jcls;
9943 {
9944 jobject obj = jarg1;
9945 if ( obj != NULL )
9946 {
9947 jclass cls = ( *jenv )->GetObjectClass( jenv, obj );
9948 mapformID = ( *jenv )->GetMethodID( jenv, cls, "mapform", "([D[D)V" );
9949 mapformClass = obj;
9950 cbenvMapform = jenv;
9951 arg1 = mapform_java;
9952 }
9953 else
9954 {
9955 arg1 = NULL;
9956 }
9957 }
9958 arg2 = (PLFLT)jarg2;
9959 arg3 = (PLFLT)jarg3;
9960 arg4 = (PLFLT)jarg4;
9961 arg5 = (PLFLT)jarg5;
9962 arg6 = (PLFLT)jarg6;
9963 arg7 = (PLFLT)jarg7;
9964 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
9965 }
9966
9967
9968 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) {
9969 PLFLT **arg1 = (PLFLT **) 0 ;
9970 PLINT arg2 ;
9971 PLINT arg3 ;
9972 PLFLT arg4 ;
9973 PLFLT arg5 ;
9974 PLFLT arg6 ;
9975 PLFLT arg7 ;
9976 PLFLT arg8 ;
9977 PLFLT arg9 ;
9978 PLFLT arg10 ;
9979 PLFLT arg11 ;
9980 PLFLT arg12 ;
9981 PLFLT arg13 ;
9982
9983 (void)jenv;
9984 (void)jcls;
9985 {
9986 jdouble **adat;
9987 jobject *ai;
9988 int nx = ( *jenv )->GetArrayLength( jenv, jarg1 );
9989 int ny = -1;
9990 int i, j;
9991 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
9992 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
9993
9994 ( *jenv )->EnsureLocalCapacity( jenv, nx );
9995
9996 for ( i = 0; i < nx; i++ )
9997 {
9998 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg1, i );
9999 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
10000
10001 if ( ny == -1 )
10002 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
10003 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
10004 {
10005 printf( "Misshapen a array.\n" );
10006 for ( j = 0; j <= i; j++ )
10007 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
10008 free( adat );
10009 free( ai );
10010 return;
10011 }
10012 }
10013
10014 Xlen = nx;
10015 Ylen = ny;
10016 setup_array_2d_d( &arg1, adat, nx, ny );
10017 arg2 = nx;
10018 arg3 = ny;
10019 for ( i = 0; i < nx; i++ )
10020 {
10021 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
10022 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
10023 }
10024
10025 free( adat );
10026 free( ai );
10027 }
10028 arg4 = (PLFLT)jarg4;
10029 arg5 = (PLFLT)jarg5;
10030 arg6 = (PLFLT)jarg6;
10031 arg7 = (PLFLT)jarg7;
10032 arg8 = (PLFLT)jarg8;
10033 arg9 = (PLFLT)jarg9;
10034 arg10 = (PLFLT)jarg10;
10035 arg11 = (PLFLT)jarg11;
10036 arg12 = (PLFLT)jarg12;
10037 arg13 = (PLFLT)jarg13;
10038 plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
10039 {
10040 free( arg1[0] );
10041 free( arg1 );
10042 }
10043 }
10044
10045
10046 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) {
10047 PLFLT **arg1 = (PLFLT **) 0 ;
10048 PLINT arg2 ;
10049 PLINT arg3 ;
10050 PLFLT arg4 ;
10051 PLFLT arg5 ;
10052 PLFLT arg6 ;
10053 PLFLT arg7 ;
10054 PLFLT arg8 ;
10055 PLFLT arg9 ;
10056 PLFLT arg10 ;
10057 PLFLT arg11 ;
10058 pltr_func arg12 ;
10059 PLPointer arg13 = (PLPointer) 0 ;
10060
10061 (void)jenv;
10062 (void)jcls;
10063 {
10064 jdouble **adat;
10065 jobject *ai;
10066 int nx = ( *jenv )->GetArrayLength( jenv, jarg1 );
10067 int ny = -1;
10068 int i, j;
10069 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
10070 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
10071
10072 ( *jenv )->EnsureLocalCapacity( jenv, nx );
10073
10074 for ( i = 0; i < nx; i++ )
10075 {
10076 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg1, i );
10077 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
10078
10079 if ( ny == -1 )
10080 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
10081 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
10082 {
10083 printf( "Misshapen a array.\n" );
10084 for ( j = 0; j <= i; j++ )
10085 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
10086 free( adat );
10087 free( ai );
10088 return;
10089 }
10090 }
10091
10092 Xlen = nx;
10093 Ylen = ny;
10094 setup_array_2d_d( &arg1, adat, nx, ny );
10095 arg2 = nx;
10096 arg3 = ny;
10097 for ( i = 0; i < nx; i++ )
10098 {
10099 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
10100 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
10101 }
10102
10103 free( adat );
10104 free( ai );
10105 }
10106 arg4 = (PLFLT)jarg4;
10107 arg5 = (PLFLT)jarg5;
10108 arg6 = (PLFLT)jarg6;
10109 arg7 = (PLFLT)jarg7;
10110 arg8 = (PLFLT)jarg8;
10111 arg9 = (PLFLT)jarg9;
10112 arg10 = (PLFLT)jarg10;
10113 arg11 = (PLFLT)jarg11;
10114 {
10115 jdouble **adat;
10116 jobject *ai;
10117 int nx = ( *jenv )->GetArrayLength( jenv, jarg12 );
10118 int ny = -1;
10119 int i, j;
10120 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
10121 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
10122
10123 ( *jenv )->EnsureLocalCapacity( jenv, nx );
10124
10125 for ( i = 0; i < nx; i++ )
10126 {
10127 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg12, i );
10128 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
10129
10130 if ( ny == -1 )
10131 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
10132 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
10133 {
10134 printf( "Misshapen a array.\n" );
10135 for ( j = 0; j <= i; j++ )
10136 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
10137 free( adat );
10138 free( ai );
10139 return;
10140 }
10141 }
10142
10143 if ( !( ( nx == Xlen + 1 && ny == Ylen + 1 ) || ( nx == Xlen + 1 && ny == 1 ) ) )
10144 {
10145 printf( "Xlen =%d, nx =%d, Ylen =%d, ny =%d\n", Xlen, nx, Ylen, ny );
10146 printf( "X vector or matrix must match matrix dimensions.\n" );
10147 for ( i = 0; i < nx; i++ )
10148 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
10149 free( adat );
10150 free( ai );
10151 return;
10152 }
10153 // Store whether second dimension is unity.
10154 Alen = ny;
10155 setup_array_2d_d( &xg, adat, nx, ny );
10156 for ( i = 0; i < nx; i++ )
10157 {
10158 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
10159 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
10160 }
10161
10162 free( adat );
10163 free( ai );
10164 arg12 = pltr2;
10165 }
10166 {
10167 jdouble **adat;
10168 jobject *ai;
10169 int nx = ( *jenv )->GetArrayLength( jenv, jarg13 );
10170 int ny = -1;
10171 int i, j;
10172 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
10173 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
10174
10175 ( *jenv )->EnsureLocalCapacity( jenv, nx );
10176
10177 for ( i = 0; i < nx; i++ )
10178 {
10179 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg13, i );
10180 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
10181
10182 if ( ny == -1 )
10183 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
10184 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
10185 {
10186 printf( "Misshapen a array.\n" );
10187 for ( j = 0; j <= i; j++ )
10188 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
10189 free( adat );
10190 free( ai );
10191 return;
10192 }
10193 }
10194
10195 if ( !( ( nx == Xlen + 1 && ny == Ylen + 1 ) || ( nx == Ylen + 1 && ny == 1 && ny == Alen ) ) )
10196 {
10197 printf( "Xlen =%d, nx =%d, Ylen =%d, Alen =%d, ny =%d\n",
10198 Xlen, nx, Ylen, Alen, ny );
10199 printf( "Y vector or matrix must match matrix dimensions.\n" );
10200 for ( i = 0; i < nx; i++ )
10201 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
10202 free( adat );
10203 free( ai );
10204 return;
10205 }
10206 setup_array_2d_d( &yg, adat, nx, ny );
10207 for ( i = 0; i < nx; i++ )
10208 {
10209 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
10210 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
10211 }
10212
10213 free( adat );
10214 free( ai );
10215 cgrid = (PLcGrid2 *) malloc( sizeof ( PLcGrid2 ) );
10216 cgrid->xg = xg;
10217 cgrid->yg = yg;
10218 cgrid->nx = nx;
10219 cgrid->ny = ny;
10220 arg13 = cgrid;
10221 }
10222 plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
10223 {
10224 free( arg1[0] );
10225 free( arg1 );
10226 }
10227 {
10228 free( xg[0] );
10229 free( xg );
10230 }
10231 {
10232 free( yg[0] );
10233 free( yg );
10234 free( cgrid );
10235 }
10236 }
10237
10238
10239 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plClearOpts(JNIEnv *jenv, jclass jcls) {
10240 (void)jenv;
10241 (void)jcls;
10242 plClearOpts();
10243 }
10244
10245
10246 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plResetOpts(JNIEnv *jenv, jclass jcls) {
10247 (void)jenv;
10248 (void)jcls;
10249 plResetOpts();
10250 }
10251
10252
10253 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plSetUsage(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
10254 char *arg1 = (char *) 0 ;
10255 char *arg2 = (char *) 0 ;
10256
10257 (void)jenv;
10258 (void)jcls;
10259 arg1 = 0;
10260 if (jarg1) {
10261 arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
10262 if (!arg1) return ;
10263 }
10264 arg2 = 0;
10265 if (jarg2) {
10266 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);
10267 if (!arg2) return ;
10268 }
10269 plSetUsage((char const *)arg1,(char const *)arg2);
10270 if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
10271 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2);
10272 }
10273
10274
10275 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plOptUsage(JNIEnv *jenv, jclass jcls) {
10276 (void)jenv;
10277 (void)jcls;
10278 plOptUsage();
10279 }
10280
10281
10282 SWIGEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plMinMax2dGrid(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jdoubleArray jarg4, jdoubleArray jarg5) {
10283 PLFLT **arg1 = (PLFLT **) 0 ;
10284 PLINT arg2 ;
10285 PLINT arg3 ;
10286 PLFLT *arg4 = (PLFLT *) 0 ;
10287 PLFLT *arg5 = (PLFLT *) 0 ;
10288 PLFLT temp4 ;
10289 PLFLT temp5 ;
10290
10291 (void)jenv;
10292 (void)jcls;
10293 {
10294 jdouble **adat;
10295 jobject *ai;
10296 int nx = ( *jenv )->GetArrayLength( jenv, jarg1 );
10297 int ny = -1;
10298 int i, j;
10299 ai = (jobject *) malloc( (size_t) nx * sizeof ( jobject ) );
10300 adat = (jdouble **) malloc( (size_t) nx * sizeof ( jdouble * ) );
10301
10302 ( *jenv )->EnsureLocalCapacity( jenv, nx );
10303
10304 for ( i = 0; i < nx; i++ )
10305 {
10306 ai[i] = ( *jenv )->GetObjectArrayElement( jenv, jarg1, i );
10307 adat[i] = ( *jenv )->GetDoubleArrayElements( jenv, ai[i], 0 );
10308
10309 if ( ny == -1 )
10310 ny = ( *jenv )->GetArrayLength( jenv, ai[i] );
10311 else if ( ny != ( *jenv )->GetArrayLength( jenv, ai[i] ) )
10312 {
10313 printf( "Misshapen a array.\n" );
10314 for ( j = 0; j <= i; j++ )
10315 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );
10316 free( adat );
10317 free( ai );
10318 return;
10319 }
10320 }
10321
10322 Xlen = nx;
10323 Ylen = ny;
10324 setup_array_2d_d( &arg1, adat, nx, ny );
10325 arg2 = nx;
10326 arg3 = ny;
10327 for ( i = 0; i < nx; i++ )
10328 {
10329 ( *jenv )->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );
10330 ( *jenv )->DeleteLocalRef( jenv, ai[i] );
10331 }
10332
10333 free( adat );
10334 free( ai );
10335 }
10336 {
10337 if (!jarg4) {
10338 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
10339 return ;
10340 }
10341 if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {
10342 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
10343 return ;
10344 }
10345 temp4 = (PLFLT)0;
10346 arg4 = &temp4;
10347 }
10348 {
10349 if (!jarg5) {
10350 SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
10351 return ;
10352 }
10353 if ((*jenv)->GetArrayLength(jenv, jarg5) == 0) {
10354 SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
10355 return ;
10356 }
10357 temp5 = (PLFLT)0;
10358 arg5 = &temp5;
10359 }
10360 plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
10361 {
10362 jdouble jvalue = (jdouble)temp4;
10363 (*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);
10364 }
10365 {
10366 jdouble jvalue = (jdouble)temp5;
10367 (*jenv)->SetDoubleArrayRegion(jenv, jarg5, 0, 1, &jvalue);
10368 }
10369 {
10370 free( arg1[0] );
10371 free( arg1 );
10372 }
10373
10374
10375 }
10376
10377
10378 SWIGEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_plGetCursor(JNIEnv *jenv, jclass jcls, jlong jarg1) {
10379 jint jresult = 0 ;
10380 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
10381 PLINT result;
10382
10383 (void)jenv;
10384 (void)jcls;
10385 arg1 = *(PLGraphicsIn **)&jarg1;
10386 result = (PLINT)plGetCursor(arg1);
10387 jresult = (jint)result;
10388 return jresult;
10389 }
10390
10391
10392 #ifdef __cplusplus
10393 }
10394 #endif
10395