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