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