8ea0cc12990d68a4f112e8ebf11688814c33f8c0
[scilab.git] / scilab / modules / graphic_objects / src / jni / DataLoader_wrap.c
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 {
142   SWIG_JavaOutOfMemoryError = 1, 
143   SWIG_JavaIOException, 
144   SWIG_JavaRuntimeException, 
145   SWIG_JavaIndexOutOfBoundsException,
146   SWIG_JavaArithmeticException,
147   SWIG_JavaIllegalArgumentException,
148   SWIG_JavaNullPointerException,
149   SWIG_JavaDirectorPureVirtual,
150   SWIG_JavaUnknownError
151 } SWIG_JavaExceptionCodes;
152
153 typedef struct {
154   SWIG_JavaExceptionCodes code;
155   const char *java_exception;
156 } SWIG_JavaExceptions_t;
157
158
159 static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) {
160   jclass excep;
161   static const SWIG_JavaExceptions_t java_exceptions[] = {
162     { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" },
163     { SWIG_JavaIOException, "java/io/IOException" },
164     { SWIG_JavaRuntimeException, "java/lang/RuntimeException" },
165     { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" },
166     { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" },
167     { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" },
168     { SWIG_JavaNullPointerException, "java/lang/NullPointerException" },
169     { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" },
170     { SWIG_JavaUnknownError,  "java/lang/UnknownError" },
171     { (SWIG_JavaExceptionCodes)0,  "java/lang/UnknownError" }
172   };
173   const SWIG_JavaExceptions_t *except_ptr = java_exceptions;
174
175   while (except_ptr->code != code && except_ptr->code)
176     except_ptr++;
177
178   (*jenv)->ExceptionClear(jenv);
179   excep = (*jenv)->FindClass(jenv, except_ptr->java_exception);
180   if (excep)
181     (*jenv)->ThrowNew(jenv, excep, msg);
182 }
183
184
185 /* Contract support */
186
187 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } else
188
189
190 #if defined(SWIG_NOINCLUDE) || defined(SWIG_NOARRAYS)
191
192
193 static int SWIG_JavaArrayInSchar (JNIEnv *jenv, jbyte **jarr, signed char **carr, jbyteArray input);
194 static void SWIG_JavaArrayArgoutSchar (JNIEnv *jenv, jbyte *jarr, signed char *carr, jbyteArray input);
195 static jbyteArray SWIG_JavaArrayOutSchar (JNIEnv *jenv, signed char *result, jsize sz);
196
197
198 static int SWIG_JavaArrayInUchar (JNIEnv *jenv, jshort **jarr, unsigned char **carr, jshortArray input);
199 static void SWIG_JavaArrayArgoutUchar (JNIEnv *jenv, jshort *jarr, unsigned char *carr, jshortArray input);
200 static jshortArray SWIG_JavaArrayOutUchar (JNIEnv *jenv, unsigned char *result, jsize sz);
201
202
203 static int SWIG_JavaArrayInShort (JNIEnv *jenv, jshort **jarr, short **carr, jshortArray input);
204 static void SWIG_JavaArrayArgoutShort (JNIEnv *jenv, jshort *jarr, short *carr, jshortArray input);
205 static jshortArray SWIG_JavaArrayOutShort (JNIEnv *jenv, short *result, jsize sz);
206
207
208 static int SWIG_JavaArrayInUshort (JNIEnv *jenv, jint **jarr, unsigned short **carr, jintArray input);
209 static void SWIG_JavaArrayArgoutUshort (JNIEnv *jenv, jint *jarr, unsigned short *carr, jintArray input);
210 static jintArray SWIG_JavaArrayOutUshort (JNIEnv *jenv, unsigned short *result, jsize sz);
211
212
213 static int SWIG_JavaArrayInInt (JNIEnv *jenv, jint **jarr, int **carr, jintArray input);
214 static void SWIG_JavaArrayArgoutInt (JNIEnv *jenv, jint *jarr, int *carr, jintArray input);
215 static jintArray SWIG_JavaArrayOutInt (JNIEnv *jenv, int *result, jsize sz);
216
217
218 static int SWIG_JavaArrayInUint (JNIEnv *jenv, jlong **jarr, unsigned int **carr, jlongArray input);
219 static void SWIG_JavaArrayArgoutUint (JNIEnv *jenv, jlong *jarr, unsigned int *carr, jlongArray input);
220 static jlongArray SWIG_JavaArrayOutUint (JNIEnv *jenv, unsigned int *result, jsize sz);
221
222
223 static int SWIG_JavaArrayInLong (JNIEnv *jenv, jint **jarr, long **carr, jintArray input);
224 static void SWIG_JavaArrayArgoutLong (JNIEnv *jenv, jint *jarr, long *carr, jintArray input);
225 static jintArray SWIG_JavaArrayOutLong (JNIEnv *jenv, long *result, jsize sz);
226
227
228 static int SWIG_JavaArrayInUlong (JNIEnv *jenv, jlong **jarr, unsigned long **carr, jlongArray input);
229 static void SWIG_JavaArrayArgoutUlong (JNIEnv *jenv, jlong *jarr, unsigned long *carr, jlongArray input);
230 static jlongArray SWIG_JavaArrayOutUlong (JNIEnv *jenv, unsigned long *result, jsize sz);
231
232
233 static int SWIG_JavaArrayInLonglong (JNIEnv *jenv, jlong **jarr, jlong **carr, jlongArray input);
234 static void SWIG_JavaArrayArgoutLonglong (JNIEnv *jenv, jlong *jarr, jlong *carr, jlongArray input);
235 static jlongArray SWIG_JavaArrayOutLonglong (JNIEnv *jenv, jlong *result, jsize sz);
236
237
238 static int SWIG_JavaArrayInFloat (JNIEnv *jenv, jfloat **jarr, float **carr, jfloatArray input);
239 static void SWIG_JavaArrayArgoutFloat (JNIEnv *jenv, jfloat *jarr, float *carr, jfloatArray input);
240 static jfloatArray SWIG_JavaArrayOutFloat (JNIEnv *jenv, float *result, jsize sz);
241
242
243 static int SWIG_JavaArrayInDouble (JNIEnv *jenv, jdouble **jarr, double **carr, jdoubleArray input);
244 static void SWIG_JavaArrayArgoutDouble (JNIEnv *jenv, jdouble *jarr, double *carr, jdoubleArray input);
245 static jdoubleArray SWIG_JavaArrayOutDouble (JNIEnv *jenv, double *result, jsize sz);
246
247
248 #else
249
250
251 /* signed char[] support */
252 static int SWIG_JavaArrayInSchar (JNIEnv *jenv, jbyte **jarr, signed char **carr, jbyteArray input) {
253   int i;
254   jsize sz;
255   if (!input) {
256     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
257     return 0;
258   }
259   sz = (*jenv)->GetArrayLength(jenv, input);
260   *jarr = (*jenv)->GetByteArrayElements(jenv, input, 0);
261   if (!*jarr)
262     return 0; 
263   *carr = (signed char*) calloc(sz, sizeof(signed char)); 
264   if (!*carr) {
265     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
266     return 0;
267   }
268   for (i=0; i<sz; i++)
269     (*carr)[i] = (signed char)(*jarr)[i];
270   return 1;
271 }
272
273 static void SWIG_JavaArrayArgoutSchar (JNIEnv *jenv, jbyte *jarr, signed char *carr, jbyteArray input) {
274   int i;
275   jsize sz = (*jenv)->GetArrayLength(jenv, input);
276   for (i=0; i<sz; i++)
277     jarr[i] = (jbyte)carr[i];
278   (*jenv)->ReleaseByteArrayElements(jenv, input, jarr, 0);
279 }
280
281 static jbyteArray SWIG_JavaArrayOutSchar (JNIEnv *jenv, signed char *result, jsize sz) {
282   jbyte *arr;
283   int i;
284   jbyteArray jresult = (*jenv)->NewByteArray(jenv, sz);
285   if (!jresult)
286     return NULL;
287   arr = (*jenv)->GetByteArrayElements(jenv, jresult, 0);
288   if (!arr)
289     return NULL;
290   for (i=0; i<sz; i++)
291     arr[i] = (jbyte)result[i];
292   (*jenv)->ReleaseByteArrayElements(jenv, jresult, arr, 0);
293   return jresult;
294 }
295
296
297 /* unsigned char[] support */
298 static int SWIG_JavaArrayInUchar (JNIEnv *jenv, jshort **jarr, unsigned char **carr, jshortArray input) {
299   int i;
300   jsize sz;
301   if (!input) {
302     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
303     return 0;
304   }
305   sz = (*jenv)->GetArrayLength(jenv, input);
306   *jarr = (*jenv)->GetShortArrayElements(jenv, input, 0);
307   if (!*jarr)
308     return 0; 
309   *carr = (unsigned char*) calloc(sz, sizeof(unsigned char)); 
310   if (!*carr) {
311     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
312     return 0;
313   }
314   for (i=0; i<sz; i++)
315     (*carr)[i] = (unsigned char)(*jarr)[i];
316   return 1;
317 }
318
319 static void SWIG_JavaArrayArgoutUchar (JNIEnv *jenv, jshort *jarr, unsigned char *carr, jshortArray input) {
320   int i;
321   jsize sz = (*jenv)->GetArrayLength(jenv, input);
322   for (i=0; i<sz; i++)
323     jarr[i] = (jshort)carr[i];
324   (*jenv)->ReleaseShortArrayElements(jenv, input, jarr, 0);
325 }
326
327 static jshortArray SWIG_JavaArrayOutUchar (JNIEnv *jenv, unsigned char *result, jsize sz) {
328   jshort *arr;
329   int i;
330   jshortArray jresult = (*jenv)->NewShortArray(jenv, sz);
331   if (!jresult)
332     return NULL;
333   arr = (*jenv)->GetShortArrayElements(jenv, jresult, 0);
334   if (!arr)
335     return NULL;
336   for (i=0; i<sz; i++)
337     arr[i] = (jshort)result[i];
338   (*jenv)->ReleaseShortArrayElements(jenv, jresult, arr, 0);
339   return jresult;
340 }
341
342
343 /* short[] support */
344 static int SWIG_JavaArrayInShort (JNIEnv *jenv, jshort **jarr, short **carr, jshortArray input) {
345   int i;
346   jsize sz;
347   if (!input) {
348     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
349     return 0;
350   }
351   sz = (*jenv)->GetArrayLength(jenv, input);
352   *jarr = (*jenv)->GetShortArrayElements(jenv, input, 0);
353   if (!*jarr)
354     return 0; 
355   *carr = (short*) calloc(sz, sizeof(short)); 
356   if (!*carr) {
357     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
358     return 0;
359   }
360   for (i=0; i<sz; i++)
361     (*carr)[i] = (short)(*jarr)[i];
362   return 1;
363 }
364
365 static void SWIG_JavaArrayArgoutShort (JNIEnv *jenv, jshort *jarr, short *carr, jshortArray input) {
366   int i;
367   jsize sz = (*jenv)->GetArrayLength(jenv, input);
368   for (i=0; i<sz; i++)
369     jarr[i] = (jshort)carr[i];
370   (*jenv)->ReleaseShortArrayElements(jenv, input, jarr, 0);
371 }
372
373 static jshortArray SWIG_JavaArrayOutShort (JNIEnv *jenv, short *result, jsize sz) {
374   jshort *arr;
375   int i;
376   jshortArray jresult = (*jenv)->NewShortArray(jenv, sz);
377   if (!jresult)
378     return NULL;
379   arr = (*jenv)->GetShortArrayElements(jenv, jresult, 0);
380   if (!arr)
381     return NULL;
382   for (i=0; i<sz; i++)
383     arr[i] = (jshort)result[i];
384   (*jenv)->ReleaseShortArrayElements(jenv, jresult, arr, 0);
385   return jresult;
386 }
387
388
389 /* unsigned short[] support */
390 static int SWIG_JavaArrayInUshort (JNIEnv *jenv, jint **jarr, unsigned short **carr, jintArray input) {
391   int i;
392   jsize sz;
393   if (!input) {
394     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
395     return 0;
396   }
397   sz = (*jenv)->GetArrayLength(jenv, input);
398   *jarr = (*jenv)->GetIntArrayElements(jenv, input, 0);
399   if (!*jarr)
400     return 0; 
401   *carr = (unsigned short*) calloc(sz, sizeof(unsigned short)); 
402   if (!*carr) {
403     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
404     return 0;
405   }
406   for (i=0; i<sz; i++)
407     (*carr)[i] = (unsigned short)(*jarr)[i];
408   return 1;
409 }
410
411 static void SWIG_JavaArrayArgoutUshort (JNIEnv *jenv, jint *jarr, unsigned short *carr, jintArray input) {
412   int i;
413   jsize sz = (*jenv)->GetArrayLength(jenv, input);
414   for (i=0; i<sz; i++)
415     jarr[i] = (jint)carr[i];
416   (*jenv)->ReleaseIntArrayElements(jenv, input, jarr, 0);
417 }
418
419 static jintArray SWIG_JavaArrayOutUshort (JNIEnv *jenv, unsigned short *result, jsize sz) {
420   jint *arr;
421   int i;
422   jintArray jresult = (*jenv)->NewIntArray(jenv, sz);
423   if (!jresult)
424     return NULL;
425   arr = (*jenv)->GetIntArrayElements(jenv, jresult, 0);
426   if (!arr)
427     return NULL;
428   for (i=0; i<sz; i++)
429     arr[i] = (jint)result[i];
430   (*jenv)->ReleaseIntArrayElements(jenv, jresult, arr, 0);
431   return jresult;
432 }
433
434
435 /* int[] support */
436 static int SWIG_JavaArrayInInt (JNIEnv *jenv, jint **jarr, int **carr, jintArray input) {
437   int i;
438   jsize sz;
439   if (!input) {
440     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
441     return 0;
442   }
443   sz = (*jenv)->GetArrayLength(jenv, input);
444   *jarr = (*jenv)->GetIntArrayElements(jenv, input, 0);
445   if (!*jarr)
446     return 0; 
447   *carr = (int*) calloc(sz, sizeof(int)); 
448   if (!*carr) {
449     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
450     return 0;
451   }
452   for (i=0; i<sz; i++)
453     (*carr)[i] = (int)(*jarr)[i];
454   return 1;
455 }
456
457 static void SWIG_JavaArrayArgoutInt (JNIEnv *jenv, jint *jarr, int *carr, jintArray input) {
458   int i;
459   jsize sz = (*jenv)->GetArrayLength(jenv, input);
460   for (i=0; i<sz; i++)
461     jarr[i] = (jint)carr[i];
462   (*jenv)->ReleaseIntArrayElements(jenv, input, jarr, 0);
463 }
464
465 static jintArray SWIG_JavaArrayOutInt (JNIEnv *jenv, int *result, jsize sz) {
466   jint *arr;
467   int i;
468   jintArray jresult = (*jenv)->NewIntArray(jenv, sz);
469   if (!jresult)
470     return NULL;
471   arr = (*jenv)->GetIntArrayElements(jenv, jresult, 0);
472   if (!arr)
473     return NULL;
474   for (i=0; i<sz; i++)
475     arr[i] = (jint)result[i];
476   (*jenv)->ReleaseIntArrayElements(jenv, jresult, arr, 0);
477   return jresult;
478 }
479
480
481 /* unsigned int[] support */
482 static int SWIG_JavaArrayInUint (JNIEnv *jenv, jlong **jarr, unsigned int **carr, jlongArray input) {
483   int i;
484   jsize sz;
485   if (!input) {
486     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
487     return 0;
488   }
489   sz = (*jenv)->GetArrayLength(jenv, input);
490   *jarr = (*jenv)->GetLongArrayElements(jenv, input, 0);
491   if (!*jarr)
492     return 0; 
493   *carr = (unsigned int*) calloc(sz, sizeof(unsigned int)); 
494   if (!*carr) {
495     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
496     return 0;
497   }
498   for (i=0; i<sz; i++)
499     (*carr)[i] = (unsigned int)(*jarr)[i];
500   return 1;
501 }
502
503 static void SWIG_JavaArrayArgoutUint (JNIEnv *jenv, jlong *jarr, unsigned int *carr, jlongArray input) {
504   int i;
505   jsize sz = (*jenv)->GetArrayLength(jenv, input);
506   for (i=0; i<sz; i++)
507     jarr[i] = (jlong)carr[i];
508   (*jenv)->ReleaseLongArrayElements(jenv, input, jarr, 0);
509 }
510
511 static jlongArray SWIG_JavaArrayOutUint (JNIEnv *jenv, unsigned int *result, jsize sz) {
512   jlong *arr;
513   int i;
514   jlongArray jresult = (*jenv)->NewLongArray(jenv, sz);
515   if (!jresult)
516     return NULL;
517   arr = (*jenv)->GetLongArrayElements(jenv, jresult, 0);
518   if (!arr)
519     return NULL;
520   for (i=0; i<sz; i++)
521     arr[i] = (jlong)result[i];
522   (*jenv)->ReleaseLongArrayElements(jenv, jresult, arr, 0);
523   return jresult;
524 }
525
526
527 /* long[] support */
528 static int SWIG_JavaArrayInLong (JNIEnv *jenv, jint **jarr, long **carr, jintArray input) {
529   int i;
530   jsize sz;
531   if (!input) {
532     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
533     return 0;
534   }
535   sz = (*jenv)->GetArrayLength(jenv, input);
536   *jarr = (*jenv)->GetIntArrayElements(jenv, input, 0);
537   if (!*jarr)
538     return 0; 
539   *carr = (long*) calloc(sz, sizeof(long)); 
540   if (!*carr) {
541     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
542     return 0;
543   }
544   for (i=0; i<sz; i++)
545     (*carr)[i] = (long)(*jarr)[i];
546   return 1;
547 }
548
549 static void SWIG_JavaArrayArgoutLong (JNIEnv *jenv, jint *jarr, long *carr, jintArray input) {
550   int i;
551   jsize sz = (*jenv)->GetArrayLength(jenv, input);
552   for (i=0; i<sz; i++)
553     jarr[i] = (jint)carr[i];
554   (*jenv)->ReleaseIntArrayElements(jenv, input, jarr, 0);
555 }
556
557 static jintArray SWIG_JavaArrayOutLong (JNIEnv *jenv, long *result, jsize sz) {
558   jint *arr;
559   int i;
560   jintArray jresult = (*jenv)->NewIntArray(jenv, sz);
561   if (!jresult)
562     return NULL;
563   arr = (*jenv)->GetIntArrayElements(jenv, jresult, 0);
564   if (!arr)
565     return NULL;
566   for (i=0; i<sz; i++)
567     arr[i] = (jint)result[i];
568   (*jenv)->ReleaseIntArrayElements(jenv, jresult, arr, 0);
569   return jresult;
570 }
571
572
573 /* unsigned long[] support */
574 static int SWIG_JavaArrayInUlong (JNIEnv *jenv, jlong **jarr, unsigned long **carr, jlongArray input) {
575   int i;
576   jsize sz;
577   if (!input) {
578     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
579     return 0;
580   }
581   sz = (*jenv)->GetArrayLength(jenv, input);
582   *jarr = (*jenv)->GetLongArrayElements(jenv, input, 0);
583   if (!*jarr)
584     return 0; 
585   *carr = (unsigned long*) calloc(sz, sizeof(unsigned long)); 
586   if (!*carr) {
587     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
588     return 0;
589   }
590   for (i=0; i<sz; i++)
591     (*carr)[i] = (unsigned long)(*jarr)[i];
592   return 1;
593 }
594
595 static void SWIG_JavaArrayArgoutUlong (JNIEnv *jenv, jlong *jarr, unsigned long *carr, jlongArray input) {
596   int i;
597   jsize sz = (*jenv)->GetArrayLength(jenv, input);
598   for (i=0; i<sz; i++)
599     jarr[i] = (jlong)carr[i];
600   (*jenv)->ReleaseLongArrayElements(jenv, input, jarr, 0);
601 }
602
603 static jlongArray SWIG_JavaArrayOutUlong (JNIEnv *jenv, unsigned long *result, jsize sz) {
604   jlong *arr;
605   int i;
606   jlongArray jresult = (*jenv)->NewLongArray(jenv, sz);
607   if (!jresult)
608     return NULL;
609   arr = (*jenv)->GetLongArrayElements(jenv, jresult, 0);
610   if (!arr)
611     return NULL;
612   for (i=0; i<sz; i++)
613     arr[i] = (jlong)result[i];
614   (*jenv)->ReleaseLongArrayElements(jenv, jresult, arr, 0);
615   return jresult;
616 }
617
618
619 /* jlong[] support */
620 static int SWIG_JavaArrayInLonglong (JNIEnv *jenv, jlong **jarr, jlong **carr, jlongArray input) {
621   int i;
622   jsize sz;
623   if (!input) {
624     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
625     return 0;
626   }
627   sz = (*jenv)->GetArrayLength(jenv, input);
628   *jarr = (*jenv)->GetLongArrayElements(jenv, input, 0);
629   if (!*jarr)
630     return 0; 
631   *carr = (jlong*) calloc(sz, sizeof(jlong)); 
632   if (!*carr) {
633     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
634     return 0;
635   }
636   for (i=0; i<sz; i++)
637     (*carr)[i] = (jlong)(*jarr)[i];
638   return 1;
639 }
640
641 static void SWIG_JavaArrayArgoutLonglong (JNIEnv *jenv, jlong *jarr, jlong *carr, jlongArray input) {
642   int i;
643   jsize sz = (*jenv)->GetArrayLength(jenv, input);
644   for (i=0; i<sz; i++)
645     jarr[i] = (jlong)carr[i];
646   (*jenv)->ReleaseLongArrayElements(jenv, input, jarr, 0);
647 }
648
649 static jlongArray SWIG_JavaArrayOutLonglong (JNIEnv *jenv, jlong *result, jsize sz) {
650   jlong *arr;
651   int i;
652   jlongArray jresult = (*jenv)->NewLongArray(jenv, sz);
653   if (!jresult)
654     return NULL;
655   arr = (*jenv)->GetLongArrayElements(jenv, jresult, 0);
656   if (!arr)
657     return NULL;
658   for (i=0; i<sz; i++)
659     arr[i] = (jlong)result[i];
660   (*jenv)->ReleaseLongArrayElements(jenv, jresult, arr, 0);
661   return jresult;
662 }
663
664
665 /* float[] support */
666 static int SWIG_JavaArrayInFloat (JNIEnv *jenv, jfloat **jarr, float **carr, jfloatArray input) {
667   int i;
668   jsize sz;
669   if (!input) {
670     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
671     return 0;
672   }
673   sz = (*jenv)->GetArrayLength(jenv, input);
674   *jarr = (*jenv)->GetFloatArrayElements(jenv, input, 0);
675   if (!*jarr)
676     return 0; 
677   *carr = (float*) calloc(sz, sizeof(float)); 
678   if (!*carr) {
679     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
680     return 0;
681   }
682   for (i=0; i<sz; i++)
683     (*carr)[i] = (float)(*jarr)[i];
684   return 1;
685 }
686
687 static void SWIG_JavaArrayArgoutFloat (JNIEnv *jenv, jfloat *jarr, float *carr, jfloatArray input) {
688   int i;
689   jsize sz = (*jenv)->GetArrayLength(jenv, input);
690   for (i=0; i<sz; i++)
691     jarr[i] = (jfloat)carr[i];
692   (*jenv)->ReleaseFloatArrayElements(jenv, input, jarr, 0);
693 }
694
695 static jfloatArray SWIG_JavaArrayOutFloat (JNIEnv *jenv, float *result, jsize sz) {
696   jfloat *arr;
697   int i;
698   jfloatArray jresult = (*jenv)->NewFloatArray(jenv, sz);
699   if (!jresult)
700     return NULL;
701   arr = (*jenv)->GetFloatArrayElements(jenv, jresult, 0);
702   if (!arr)
703     return NULL;
704   for (i=0; i<sz; i++)
705     arr[i] = (jfloat)result[i];
706   (*jenv)->ReleaseFloatArrayElements(jenv, jresult, arr, 0);
707   return jresult;
708 }
709
710
711 /* double[] support */
712 static int SWIG_JavaArrayInDouble (JNIEnv *jenv, jdouble **jarr, double **carr, jdoubleArray input) {
713   int i;
714   jsize sz;
715   if (!input) {
716     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
717     return 0;
718   }
719   sz = (*jenv)->GetArrayLength(jenv, input);
720   *jarr = (*jenv)->GetDoubleArrayElements(jenv, input, 0);
721   if (!*jarr)
722     return 0; 
723   *carr = (double*) calloc(sz, sizeof(double)); 
724   if (!*carr) {
725     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
726     return 0;
727   }
728   for (i=0; i<sz; i++)
729     (*carr)[i] = (double)(*jarr)[i];
730   return 1;
731 }
732
733 static void SWIG_JavaArrayArgoutDouble (JNIEnv *jenv, jdouble *jarr, double *carr, jdoubleArray input) {
734   int i;
735   jsize sz = (*jenv)->GetArrayLength(jenv, input);
736   for (i=0; i<sz; i++)
737     jarr[i] = (jdouble)carr[i];
738   (*jenv)->ReleaseDoubleArrayElements(jenv, input, jarr, 0);
739 }
740
741 static jdoubleArray SWIG_JavaArrayOutDouble (JNIEnv *jenv, double *result, jsize sz) {
742   jdouble *arr;
743   int i;
744   jdoubleArray jresult = (*jenv)->NewDoubleArray(jenv, sz);
745   if (!jresult)
746     return NULL;
747   arr = (*jenv)->GetDoubleArrayElements(jenv, jresult, 0);
748   if (!arr)
749     return NULL;
750   for (i=0; i<sz; i++)
751     arr[i] = (jdouble)result[i];
752   (*jenv)->ReleaseDoubleArrayElements(jenv, jresult, arr, 0);
753   return jresult;
754 }
755
756
757 #endif
758
759
760   #include "DataLoader.hxx"
761
762
763 #ifdef __cplusplus
764 extern "C" {
765 #endif
766
767 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_getTextureWidth(JNIEnv *jenv, jclass jcls, jint jarg1) {
768   jint jresult = 0 ;
769   int arg1 ;
770   int result;
771   
772   (void)jenv;
773   (void)jcls;
774   arg1 = (int)jarg1; 
775   result = (int)getTextureWidth(arg1);
776   jresult = (jint)result; 
777   return jresult;
778 }
779
780
781 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_getTextureHeight(JNIEnv *jenv, jclass jcls, jint jarg1) {
782   jint jresult = 0 ;
783   int arg1 ;
784   int result;
785   
786   (void)jenv;
787   (void)jcls;
788   arg1 = (int)jarg1; 
789   result = (int)getTextureHeight(arg1);
790   jresult = (jint)result; 
791   return jresult;
792 }
793
794
795 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_fillTextureData(JNIEnv *jenv, jclass jcls, jint jarg1, jobject jarg2, jint jarg3) {
796   jint jresult = 0 ;
797   int arg1 ;
798   unsigned char *arg2 = (unsigned char *) 0 ;
799   int arg3 ;
800   int result;
801   
802   (void)jenv;
803   (void)jcls;
804   arg1 = (int)jarg1; 
805   {
806     arg2 = (*jenv)->GetDirectBufferAddress(jenv, jarg2);
807     if (arg2 == NULL) {
808       SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
809     }
810   }
811   arg3 = (int)jarg3; 
812   result = (int)fillTextureData(arg1,arg2,arg3);
813   jresult = (jint)result; 
814   return jresult;
815 }
816
817
818 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_fillSubTextureData(JNIEnv *jenv, jclass jcls, jint jarg1, jobject jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7) {
819   jint jresult = 0 ;
820   int arg1 ;
821   unsigned char *arg2 = (unsigned char *) 0 ;
822   int arg3 ;
823   int arg4 ;
824   int arg5 ;
825   int arg6 ;
826   int arg7 ;
827   int result;
828   
829   (void)jenv;
830   (void)jcls;
831   arg1 = (int)jarg1; 
832   {
833     arg2 = (*jenv)->GetDirectBufferAddress(jenv, jarg2);
834     if (arg2 == NULL) {
835       SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
836     }
837   }
838   arg3 = (int)jarg3; 
839   arg4 = (int)jarg4; 
840   arg5 = (int)jarg5; 
841   arg6 = (int)jarg6; 
842   arg7 = (int)jarg7; 
843   result = (int)fillSubTextureData(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
844   jresult = (jint)result; 
845   return jresult;
846 }
847
848
849 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_getDataSize(JNIEnv *jenv, jclass jcls, jint jarg1) {
850   jint jresult = 0 ;
851   int arg1 ;
852   int result;
853   
854   (void)jenv;
855   (void)jcls;
856   arg1 = (int)jarg1; 
857   result = (int)getDataSize(arg1);
858   jresult = (jint)result; 
859   return jresult;
860 }
861
862
863 SWIGEXPORT void JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_fillVertices(JNIEnv *jenv, jclass jcls, jint jarg1, jobject jarg2, jint jarg3, jint jarg4, jint jarg5, jdoubleArray jarg6, jdoubleArray jarg7, jint jarg8) {
864   int arg1 ;
865   float *arg2 = (float *) 0 ;
866   int arg3 ;
867   int arg4 ;
868   int arg5 ;
869   double *arg6 ;
870   double *arg7 ;
871   int arg8 ;
872   jdouble *jarr6 ;
873   jdouble *jarr7 ;
874   
875   (void)jenv;
876   (void)jcls;
877   arg1 = (int)jarg1; 
878   {
879     arg2 = (*jenv)->GetDirectBufferAddress(jenv, jarg2);
880     if (arg2 == NULL) {
881       SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
882     }
883   }
884   arg3 = (int)jarg3; 
885   arg4 = (int)jarg4; 
886   arg5 = (int)jarg5; 
887   if (!SWIG_JavaArrayInDouble(jenv, &jarr6, (double **)&arg6, jarg6)) return ; 
888   if (!SWIG_JavaArrayInDouble(jenv, &jarr7, (double **)&arg7, jarg7)) return ; 
889   arg8 = (int)jarg8; 
890   fillVertices(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
891   SWIG_JavaArrayArgoutDouble(jenv, jarr6, (double *)arg6, jarg6); 
892   SWIG_JavaArrayArgoutDouble(jenv, jarr7, (double *)arg7, jarg7); 
893   free(arg6); 
894   free(arg7); 
895 }
896
897
898 SWIGEXPORT void JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_fillNormals(JNIEnv *jenv, jclass jcls, jint jarg1, jobject jarg2, jobject jarg3, jint jarg4, jint jarg5) {
899   int arg1 ;
900   float *arg2 = (float *) 0 ;
901   float *arg3 = (float *) 0 ;
902   int arg4 ;
903   int arg5 ;
904   
905   (void)jenv;
906   (void)jcls;
907   arg1 = (int)jarg1; 
908   {
909     arg2 = (*jenv)->GetDirectBufferAddress(jenv, jarg2);
910     if (arg2 == NULL) {
911       SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
912     }
913   }
914   {
915     arg3 = (*jenv)->GetDirectBufferAddress(jenv, jarg3);
916     if (arg3 == NULL) {
917       SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
918     }
919   }
920   arg4 = (int)jarg4; 
921   arg5 = (int)jarg5; 
922   fillNormals(arg1,arg2,arg3,arg4,arg5);
923 }
924
925
926 SWIGEXPORT void JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_fillColors(JNIEnv *jenv, jclass jcls, jint jarg1, jobject jarg2, jint jarg3, jint jarg4) {
927   int arg1 ;
928   float *arg2 = (float *) 0 ;
929   int arg3 ;
930   int arg4 ;
931   
932   (void)jenv;
933   (void)jcls;
934   arg1 = (int)jarg1; 
935   {
936     arg2 = (*jenv)->GetDirectBufferAddress(jenv, jarg2);
937     if (arg2 == NULL) {
938       SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
939     }
940   }
941   arg3 = (int)jarg3; 
942   arg4 = (int)jarg4; 
943   fillColors(arg1,arg2,arg3,arg4);
944 }
945
946
947 SWIGEXPORT void JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_fillTextureCoordinates(JNIEnv *jenv, jclass jcls, jint jarg1, jobject jarg2, jint jarg3) {
948   int arg1 ;
949   float *arg2 = (float *) 0 ;
950   int arg3 ;
951   
952   (void)jenv;
953   (void)jcls;
954   arg1 = (int)jarg1; 
955   {
956     arg2 = (*jenv)->GetDirectBufferAddress(jenv, jarg2);
957     if (arg2 == NULL) {
958       SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
959     }
960   }
961   arg3 = (int)jarg3; 
962   fillTextureCoordinates(arg1,arg2,arg3);
963 }
964
965
966 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_getIndicesSize(JNIEnv *jenv, jclass jcls, jint jarg1) {
967   jint jresult = 0 ;
968   int arg1 ;
969   int result;
970   
971   (void)jenv;
972   (void)jcls;
973   arg1 = (int)jarg1; 
974   result = (int)getIndicesSize(arg1);
975   jresult = (jint)result; 
976   return jresult;
977 }
978
979
980 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_fillIndices(JNIEnv *jenv, jclass jcls, jint jarg1, jobject jarg2, jint jarg3, jint jarg4) {
981   jint jresult = 0 ;
982   int arg1 ;
983   int *arg2 = (int *) 0 ;
984   int arg3 ;
985   int arg4 ;
986   int result;
987   
988   (void)jenv;
989   (void)jcls;
990   arg1 = (int)jarg1; 
991   {
992     arg2 = (*jenv)->GetDirectBufferAddress(jenv, jarg2);
993     if (arg2 == NULL) {
994       SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
995     }
996   }
997   arg3 = (int)jarg3; 
998   arg4 = (int)jarg4; 
999   result = (int)fillIndices(arg1,arg2,arg3,arg4);
1000   jresult = (jint)result; 
1001   return jresult;
1002 }
1003
1004
1005 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_getWireIndicesSize(JNIEnv *jenv, jclass jcls, jint jarg1) {
1006   jint jresult = 0 ;
1007   int arg1 ;
1008   int result;
1009   
1010   (void)jenv;
1011   (void)jcls;
1012   arg1 = (int)jarg1; 
1013   result = (int)getWireIndicesSize(arg1);
1014   jresult = (jint)result; 
1015   return jresult;
1016 }
1017
1018
1019 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_fillWireIndices(JNIEnv *jenv, jclass jcls, jint jarg1, jobject jarg2, jint jarg3, jint jarg4) {
1020   jint jresult = 0 ;
1021   int arg1 ;
1022   int *arg2 = (int *) 0 ;
1023   int arg3 ;
1024   int arg4 ;
1025   int result;
1026   
1027   (void)jenv;
1028   (void)jcls;
1029   arg1 = (int)jarg1; 
1030   {
1031     arg2 = (*jenv)->GetDirectBufferAddress(jenv, jarg2);
1032     if (arg2 == NULL) {
1033       SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
1034     }
1035   }
1036   arg3 = (int)jarg3; 
1037   arg4 = (int)jarg4; 
1038   result = (int)fillWireIndices(arg1,arg2,arg3,arg4);
1039   jresult = (jint)result; 
1040   return jresult;
1041 }
1042
1043
1044 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_getMarkIndicesSize(JNIEnv *jenv, jclass jcls, jint jarg1) {
1045   jint jresult = 0 ;
1046   int arg1 ;
1047   int result;
1048   
1049   (void)jenv;
1050   (void)jcls;
1051   arg1 = (int)jarg1; 
1052   result = (int)getMarkIndicesSize(arg1);
1053   jresult = (jint)result; 
1054   return jresult;
1055 }
1056
1057
1058 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_fillMarkIndices(JNIEnv *jenv, jclass jcls, jint jarg1, jobject jarg2, jint jarg3) {
1059   jint jresult = 0 ;
1060   int arg1 ;
1061   int *arg2 = (int *) 0 ;
1062   int arg3 ;
1063   int result;
1064   
1065   (void)jenv;
1066   (void)jcls;
1067   arg1 = (int)jarg1; 
1068   {
1069     arg2 = (*jenv)->GetDirectBufferAddress(jenv, jarg2);
1070     if (arg2 == NULL) {
1071       SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
1072     }
1073   }
1074   arg3 = (int)jarg3; 
1075   result = (int)fillMarkIndices(arg1,arg2,arg3);
1076   jresult = (jint)result; 
1077   return jresult;
1078 }
1079
1080
1081 SWIGEXPORT jobject JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_getTextureData(JNIEnv *jenv, jclass jcls, jint jarg1) {
1082   jobject jresult = 0 ;
1083   int arg1 ;
1084   JavaDirectBuffer result;
1085   
1086   (void)jenv;
1087   (void)jcls;
1088   arg1 = (int)jarg1; 
1089   result = getTextureData(arg1);
1090   {
1091     if ((&result)->address)
1092     {
1093       jresult = (*jenv)->NewDirectByteBuffer(jenv, (&result)->address, (&result)->size);
1094     }
1095   }
1096   return jresult;
1097 }
1098
1099
1100 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_getTextureImageType(JNIEnv *jenv, jclass jcls, jint jarg1) {
1101   jint jresult = 0 ;
1102   int arg1 ;
1103   int result;
1104   
1105   (void)jenv;
1106   (void)jcls;
1107   arg1 = (int)jarg1; 
1108   result = (int)getTextureImageType(arg1);
1109   jresult = (jint)result; 
1110   return jresult;
1111 }
1112
1113
1114 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_getTextureDataType(JNIEnv *jenv, jclass jcls, jint jarg1) {
1115   jint jresult = 0 ;
1116   int arg1 ;
1117   int result;
1118   
1119   (void)jenv;
1120   (void)jcls;
1121   arg1 = (int)jarg1; 
1122   result = (int)getTextureDataType(arg1);
1123   jresult = (jint)result; 
1124   return jresult;
1125 }
1126
1127
1128 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_getTextureGLType(JNIEnv *jenv, jclass jcls, jint jarg1) {
1129   jint jresult = 0 ;
1130   int arg1 ;
1131   int result;
1132   
1133   (void)jenv;
1134   (void)jcls;
1135   arg1 = (int)jarg1; 
1136   result = (int)getTextureGLType(arg1);
1137   jresult = (jint)result; 
1138   return jresult;
1139 }
1140
1141
1142 SWIGEXPORT void JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_disposeTextureData(JNIEnv *jenv, jclass jcls, jint jarg1, jobject jarg2) {
1143   int arg1 ;
1144   unsigned char *arg2 = (unsigned char *) 0 ;
1145   
1146   (void)jenv;
1147   (void)jcls;
1148   arg1 = (int)jarg1; 
1149   {
1150     arg2 = (*jenv)->GetDirectBufferAddress(jenv, jarg2);
1151     if (arg2 == NULL) {
1152       SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
1153     }
1154   }
1155   disposeTextureData(arg1,arg2);
1156 }
1157
1158
1159 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_isTextureRowOrder(JNIEnv *jenv, jclass jcls, jint jarg1) {
1160   jint jresult = 0 ;
1161   int arg1 ;
1162   int result;
1163   
1164   (void)jenv;
1165   (void)jcls;
1166   arg1 = (int)jarg1; 
1167   result = (int)isTextureRowOrder(arg1);
1168   jresult = (jint)result; 
1169   return jresult;
1170 }
1171
1172
1173 SWIGEXPORT void JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_setABGRExt(JNIEnv *jenv, jclass jcls, jint jarg1) {
1174   int arg1 ;
1175   
1176   (void)jenv;
1177   (void)jcls;
1178   arg1 = (int)jarg1; 
1179   setABGRExt(arg1);
1180 }
1181
1182
1183 #ifdef __cplusplus
1184 }
1185 #endif
1186