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