Compilation: upgrade swig generated files to swig-3.0.7
[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 3.0.7
4  *
5  * This file is not intended to be easily readable and contains a number of
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG
8  * interface file instead.
9  * ----------------------------------------------------------------------------- */
10
11 #define SWIGJAVA
12
13 /* -----------------------------------------------------------------------------
14  *  This section contains generic SWIG labels for method/variable
15  *  declarations/attributes, and other compiler dependent labels.
16  * ----------------------------------------------------------------------------- */
17
18 /* template workaround for compilers that cannot correctly implement the C++ standard */
19 #ifndef SWIGTEMPLATEDISAMBIGUATOR
20 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
21 #  define SWIGTEMPLATEDISAMBIGUATOR template
22 # elif defined(__HP_aCC)
23 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
24 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
25 #  define SWIGTEMPLATEDISAMBIGUATOR template
26 # else
27 #  define SWIGTEMPLATEDISAMBIGUATOR
28 # endif
29 #endif
30
31 /* inline attribute */
32 #ifndef SWIGINLINE
33 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
34 #   define SWIGINLINE inline
35 # else
36 #   define SWIGINLINE
37 # endif
38 #endif
39
40 /* attribute recognised by some compilers to avoid 'unused' warnings */
41 #ifndef SWIGUNUSED
42 # if defined(__GNUC__)
43 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
44 #     define SWIGUNUSED __attribute__ ((__unused__))
45 #   else
46 #     define SWIGUNUSED
47 #   endif
48 # elif defined(__ICC)
49 #   define SWIGUNUSED __attribute__ ((__unused__))
50 # else
51 #   define SWIGUNUSED
52 # endif
53 #endif
54
55 #ifndef SWIG_MSC_UNSUPPRESS_4505
56 # if defined(_MSC_VER)
57 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
58 # endif
59 #endif
60
61 #ifndef SWIGUNUSEDPARM
62 # ifdef __cplusplus
63 #   define SWIGUNUSEDPARM(p)
64 # else
65 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
66 # endif
67 #endif
68
69 /* internal SWIG method */
70 #ifndef SWIGINTERN
71 # define SWIGINTERN static SWIGUNUSED
72 #endif
73
74 /* internal inline SWIG method */
75 #ifndef SWIGINTERNINLINE
76 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
77 #endif
78
79 /* exporting methods */
80 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
81 #  ifndef GCC_HASCLASSVISIBILITY
82 #    define GCC_HASCLASSVISIBILITY
83 #  endif
84 #endif
85
86 #ifndef SWIGEXPORT
87 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
88 #   if defined(STATIC_LINKED)
89 #     define SWIGEXPORT
90 #   else
91 #     define SWIGEXPORT __declspec(dllexport)
92 #   endif
93 # else
94 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
95 #     define SWIGEXPORT __attribute__ ((visibility("default")))
96 #   else
97 #     define SWIGEXPORT
98 #   endif
99 # endif
100 #endif
101
102 /* calling conventions for Windows */
103 #ifndef SWIGSTDCALL
104 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
105 #   define SWIGSTDCALL __stdcall
106 # else
107 #   define SWIGSTDCALL
108 # endif
109 #endif
110
111 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
112 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
113 # define _CRT_SECURE_NO_DEPRECATE
114 #endif
115
116 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
117 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
118 # define _SCL_SECURE_NO_DEPRECATE
119 #endif
120
121 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
122 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
123 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
124 #endif
125
126 /* Intel's compiler complains if a variable which was never initialised is
127  * cast to void, which is a common idiom which we use to indicate that we
128  * are aware a variable isn't used.  So we just silence that warning.
129  * See: https://github.com/swig/swig/issues/192 for more discussion.
130  */
131 #ifdef __INTEL_COMPILER
132 # pragma warning disable 592
133 #endif
134
135
136 /* Fix for jlong on some versions of gcc on Windows */
137 #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
138   typedef long long __int64;
139 #endif
140
141 /* Fix for jlong on 64-bit x86 Solaris */
142 #if defined(__x86_64)
143 # ifdef _LP64
144 #   undef _LP64
145 # endif
146 #endif
147
148 #include <jni.h>
149 #include <stdlib.h>
150 #include <string.h>
151
152
153 /* Support for throwing Java exceptions */
154 typedef enum {
155   SWIG_JavaOutOfMemoryError = 1, 
156   SWIG_JavaIOException, 
157   SWIG_JavaRuntimeException, 
158   SWIG_JavaIndexOutOfBoundsException,
159   SWIG_JavaArithmeticException,
160   SWIG_JavaIllegalArgumentException,
161   SWIG_JavaNullPointerException,
162   SWIG_JavaDirectorPureVirtual,
163   SWIG_JavaUnknownError
164 } SWIG_JavaExceptionCodes;
165
166 typedef struct {
167   SWIG_JavaExceptionCodes code;
168   const char *java_exception;
169 } SWIG_JavaExceptions_t;
170
171
172 static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) {
173   jclass excep;
174   static const SWIG_JavaExceptions_t java_exceptions[] = {
175     { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" },
176     { SWIG_JavaIOException, "java/io/IOException" },
177     { SWIG_JavaRuntimeException, "java/lang/RuntimeException" },
178     { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" },
179     { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" },
180     { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" },
181     { SWIG_JavaNullPointerException, "java/lang/NullPointerException" },
182     { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" },
183     { SWIG_JavaUnknownError,  "java/lang/UnknownError" },
184     { (SWIG_JavaExceptionCodes)0,  "java/lang/UnknownError" }
185   };
186   const SWIG_JavaExceptions_t *except_ptr = java_exceptions;
187
188   while (except_ptr->code != code && except_ptr->code)
189     except_ptr++;
190
191   (*jenv)->ExceptionClear(jenv);
192   excep = (*jenv)->FindClass(jenv, except_ptr->java_exception);
193   if (excep)
194     (*jenv)->ThrowNew(jenv, excep, msg);
195 }
196
197
198 /* Contract support */
199
200 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } else
201
202
203 #if defined(SWIG_NOINCLUDE) || defined(SWIG_NOARRAYS)
204
205
206 static int SWIG_JavaArrayInSchar (JNIEnv *jenv, jbyte **jarr, signed char **carr, jbyteArray input);
207 static void SWIG_JavaArrayArgoutSchar (JNIEnv *jenv, jbyte *jarr, signed char *carr, jbyteArray input);
208 static jbyteArray SWIG_JavaArrayOutSchar (JNIEnv *jenv, signed char *result, jsize sz);
209
210
211 static int SWIG_JavaArrayInUchar (JNIEnv *jenv, jshort **jarr, unsigned char **carr, jshortArray input);
212 static void SWIG_JavaArrayArgoutUchar (JNIEnv *jenv, jshort *jarr, unsigned char *carr, jshortArray input);
213 static jshortArray SWIG_JavaArrayOutUchar (JNIEnv *jenv, unsigned char *result, jsize sz);
214
215
216 static int SWIG_JavaArrayInShort (JNIEnv *jenv, jshort **jarr, short **carr, jshortArray input);
217 static void SWIG_JavaArrayArgoutShort (JNIEnv *jenv, jshort *jarr, short *carr, jshortArray input);
218 static jshortArray SWIG_JavaArrayOutShort (JNIEnv *jenv, short *result, jsize sz);
219
220
221 static int SWIG_JavaArrayInUshort (JNIEnv *jenv, jint **jarr, unsigned short **carr, jintArray input);
222 static void SWIG_JavaArrayArgoutUshort (JNIEnv *jenv, jint *jarr, unsigned short *carr, jintArray input);
223 static jintArray SWIG_JavaArrayOutUshort (JNIEnv *jenv, unsigned short *result, jsize sz);
224
225
226 static int SWIG_JavaArrayInInt (JNIEnv *jenv, jint **jarr, int **carr, jintArray input);
227 static void SWIG_JavaArrayArgoutInt (JNIEnv *jenv, jint *jarr, int *carr, jintArray input);
228 static jintArray SWIG_JavaArrayOutInt (JNIEnv *jenv, int *result, jsize sz);
229
230
231 static int SWIG_JavaArrayInUint (JNIEnv *jenv, jlong **jarr, unsigned int **carr, jlongArray input);
232 static void SWIG_JavaArrayArgoutUint (JNIEnv *jenv, jlong *jarr, unsigned int *carr, jlongArray input);
233 static jlongArray SWIG_JavaArrayOutUint (JNIEnv *jenv, unsigned int *result, jsize sz);
234
235
236 static int SWIG_JavaArrayInLong (JNIEnv *jenv, jint **jarr, long **carr, jintArray input);
237 static void SWIG_JavaArrayArgoutLong (JNIEnv *jenv, jint *jarr, long *carr, jintArray input);
238 static jintArray SWIG_JavaArrayOutLong (JNIEnv *jenv, long *result, jsize sz);
239
240
241 static int SWIG_JavaArrayInUlong (JNIEnv *jenv, jlong **jarr, unsigned long **carr, jlongArray input);
242 static void SWIG_JavaArrayArgoutUlong (JNIEnv *jenv, jlong *jarr, unsigned long *carr, jlongArray input);
243 static jlongArray SWIG_JavaArrayOutUlong (JNIEnv *jenv, unsigned long *result, jsize sz);
244
245
246 static int SWIG_JavaArrayInLonglong (JNIEnv *jenv, jlong **jarr, jlong **carr, jlongArray input);
247 static void SWIG_JavaArrayArgoutLonglong (JNIEnv *jenv, jlong *jarr, jlong *carr, jlongArray input);
248 static jlongArray SWIG_JavaArrayOutLonglong (JNIEnv *jenv, jlong *result, jsize sz);
249
250
251 static int SWIG_JavaArrayInFloat (JNIEnv *jenv, jfloat **jarr, float **carr, jfloatArray input);
252 static void SWIG_JavaArrayArgoutFloat (JNIEnv *jenv, jfloat *jarr, float *carr, jfloatArray input);
253 static jfloatArray SWIG_JavaArrayOutFloat (JNIEnv *jenv, float *result, jsize sz);
254
255
256 static int SWIG_JavaArrayInDouble (JNIEnv *jenv, jdouble **jarr, double **carr, jdoubleArray input);
257 static void SWIG_JavaArrayArgoutDouble (JNIEnv *jenv, jdouble *jarr, double *carr, jdoubleArray input);
258 static jdoubleArray SWIG_JavaArrayOutDouble (JNIEnv *jenv, double *result, jsize sz);
259
260
261 #else
262
263
264 /* signed char[] support */
265 static int SWIG_JavaArrayInSchar (JNIEnv *jenv, jbyte **jarr, signed char **carr, jbyteArray input) {
266   int i;
267   jsize sz;
268   if (!input) {
269     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
270     return 0;
271   }
272   sz = (*jenv)->GetArrayLength(jenv, input);
273   *jarr = (*jenv)->GetByteArrayElements(jenv, input, 0);
274   if (!*jarr)
275     return 0; 
276   *carr = (signed char*) malloc(sz * sizeof(signed char)); 
277   if (!*carr) {
278     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
279     return 0;
280   }
281   for (i=0; i<sz; i++)
282     (*carr)[i] = (signed char)(*jarr)[i];
283   return 1;
284 }
285
286 static void SWIG_JavaArrayArgoutSchar (JNIEnv *jenv, jbyte *jarr, signed char *carr, jbyteArray input) {
287   int i;
288   jsize sz = (*jenv)->GetArrayLength(jenv, input);
289   for (i=0; i<sz; i++)
290     jarr[i] = (jbyte)carr[i];
291   (*jenv)->ReleaseByteArrayElements(jenv, input, jarr, 0);
292 }
293
294 static jbyteArray SWIG_JavaArrayOutSchar (JNIEnv *jenv, signed char *result, jsize sz) {
295   jbyte *arr;
296   int i;
297   jbyteArray jresult = (*jenv)->NewByteArray(jenv, sz);
298   if (!jresult)
299     return NULL;
300   arr = (*jenv)->GetByteArrayElements(jenv, jresult, 0);
301   if (!arr)
302     return NULL;
303   for (i=0; i<sz; i++)
304     arr[i] = (jbyte)result[i];
305   (*jenv)->ReleaseByteArrayElements(jenv, jresult, arr, 0);
306   return jresult;
307 }
308
309
310 /* unsigned char[] support */
311 static int SWIG_JavaArrayInUchar (JNIEnv *jenv, jshort **jarr, unsigned char **carr, jshortArray input) {
312   int i;
313   jsize sz;
314   if (!input) {
315     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
316     return 0;
317   }
318   sz = (*jenv)->GetArrayLength(jenv, input);
319   *jarr = (*jenv)->GetShortArrayElements(jenv, input, 0);
320   if (!*jarr)
321     return 0; 
322   *carr = (unsigned char*) malloc(sz * sizeof(unsigned char)); 
323   if (!*carr) {
324     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
325     return 0;
326   }
327   for (i=0; i<sz; i++)
328     (*carr)[i] = (unsigned char)(*jarr)[i];
329   return 1;
330 }
331
332 static void SWIG_JavaArrayArgoutUchar (JNIEnv *jenv, jshort *jarr, unsigned char *carr, jshortArray input) {
333   int i;
334   jsize sz = (*jenv)->GetArrayLength(jenv, input);
335   for (i=0; i<sz; i++)
336     jarr[i] = (jshort)carr[i];
337   (*jenv)->ReleaseShortArrayElements(jenv, input, jarr, 0);
338 }
339
340 static jshortArray SWIG_JavaArrayOutUchar (JNIEnv *jenv, unsigned char *result, jsize sz) {
341   jshort *arr;
342   int i;
343   jshortArray jresult = (*jenv)->NewShortArray(jenv, sz);
344   if (!jresult)
345     return NULL;
346   arr = (*jenv)->GetShortArrayElements(jenv, jresult, 0);
347   if (!arr)
348     return NULL;
349   for (i=0; i<sz; i++)
350     arr[i] = (jshort)result[i];
351   (*jenv)->ReleaseShortArrayElements(jenv, jresult, arr, 0);
352   return jresult;
353 }
354
355
356 /* short[] support */
357 static int SWIG_JavaArrayInShort (JNIEnv *jenv, jshort **jarr, short **carr, jshortArray input) {
358   int i;
359   jsize sz;
360   if (!input) {
361     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
362     return 0;
363   }
364   sz = (*jenv)->GetArrayLength(jenv, input);
365   *jarr = (*jenv)->GetShortArrayElements(jenv, input, 0);
366   if (!*jarr)
367     return 0; 
368   *carr = (short*) malloc(sz * sizeof(short)); 
369   if (!*carr) {
370     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
371     return 0;
372   }
373   for (i=0; i<sz; i++)
374     (*carr)[i] = (short)(*jarr)[i];
375   return 1;
376 }
377
378 static void SWIG_JavaArrayArgoutShort (JNIEnv *jenv, jshort *jarr, short *carr, jshortArray input) {
379   int i;
380   jsize sz = (*jenv)->GetArrayLength(jenv, input);
381   for (i=0; i<sz; i++)
382     jarr[i] = (jshort)carr[i];
383   (*jenv)->ReleaseShortArrayElements(jenv, input, jarr, 0);
384 }
385
386 static jshortArray SWIG_JavaArrayOutShort (JNIEnv *jenv, short *result, jsize sz) {
387   jshort *arr;
388   int i;
389   jshortArray jresult = (*jenv)->NewShortArray(jenv, sz);
390   if (!jresult)
391     return NULL;
392   arr = (*jenv)->GetShortArrayElements(jenv, jresult, 0);
393   if (!arr)
394     return NULL;
395   for (i=0; i<sz; i++)
396     arr[i] = (jshort)result[i];
397   (*jenv)->ReleaseShortArrayElements(jenv, jresult, arr, 0);
398   return jresult;
399 }
400
401
402 /* unsigned short[] support */
403 static int SWIG_JavaArrayInUshort (JNIEnv *jenv, jint **jarr, unsigned short **carr, jintArray input) {
404   int i;
405   jsize sz;
406   if (!input) {
407     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
408     return 0;
409   }
410   sz = (*jenv)->GetArrayLength(jenv, input);
411   *jarr = (*jenv)->GetIntArrayElements(jenv, input, 0);
412   if (!*jarr)
413     return 0; 
414   *carr = (unsigned short*) malloc(sz * sizeof(unsigned short)); 
415   if (!*carr) {
416     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
417     return 0;
418   }
419   for (i=0; i<sz; i++)
420     (*carr)[i] = (unsigned short)(*jarr)[i];
421   return 1;
422 }
423
424 static void SWIG_JavaArrayArgoutUshort (JNIEnv *jenv, jint *jarr, unsigned short *carr, jintArray input) {
425   int i;
426   jsize sz = (*jenv)->GetArrayLength(jenv, input);
427   for (i=0; i<sz; i++)
428     jarr[i] = (jint)carr[i];
429   (*jenv)->ReleaseIntArrayElements(jenv, input, jarr, 0);
430 }
431
432 static jintArray SWIG_JavaArrayOutUshort (JNIEnv *jenv, unsigned short *result, jsize sz) {
433   jint *arr;
434   int i;
435   jintArray jresult = (*jenv)->NewIntArray(jenv, sz);
436   if (!jresult)
437     return NULL;
438   arr = (*jenv)->GetIntArrayElements(jenv, jresult, 0);
439   if (!arr)
440     return NULL;
441   for (i=0; i<sz; i++)
442     arr[i] = (jint)result[i];
443   (*jenv)->ReleaseIntArrayElements(jenv, jresult, arr, 0);
444   return jresult;
445 }
446
447
448 /* int[] support */
449 static int SWIG_JavaArrayInInt (JNIEnv *jenv, jint **jarr, int **carr, jintArray input) {
450   int i;
451   jsize sz;
452   if (!input) {
453     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
454     return 0;
455   }
456   sz = (*jenv)->GetArrayLength(jenv, input);
457   *jarr = (*jenv)->GetIntArrayElements(jenv, input, 0);
458   if (!*jarr)
459     return 0; 
460   *carr = (int*) malloc(sz * sizeof(int)); 
461   if (!*carr) {
462     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
463     return 0;
464   }
465   for (i=0; i<sz; i++)
466     (*carr)[i] = (int)(*jarr)[i];
467   return 1;
468 }
469
470 static void SWIG_JavaArrayArgoutInt (JNIEnv *jenv, jint *jarr, int *carr, jintArray input) {
471   int i;
472   jsize sz = (*jenv)->GetArrayLength(jenv, input);
473   for (i=0; i<sz; i++)
474     jarr[i] = (jint)carr[i];
475   (*jenv)->ReleaseIntArrayElements(jenv, input, jarr, 0);
476 }
477
478 static jintArray SWIG_JavaArrayOutInt (JNIEnv *jenv, int *result, jsize sz) {
479   jint *arr;
480   int i;
481   jintArray jresult = (*jenv)->NewIntArray(jenv, sz);
482   if (!jresult)
483     return NULL;
484   arr = (*jenv)->GetIntArrayElements(jenv, jresult, 0);
485   if (!arr)
486     return NULL;
487   for (i=0; i<sz; i++)
488     arr[i] = (jint)result[i];
489   (*jenv)->ReleaseIntArrayElements(jenv, jresult, arr, 0);
490   return jresult;
491 }
492
493
494 /* unsigned int[] support */
495 static int SWIG_JavaArrayInUint (JNIEnv *jenv, jlong **jarr, unsigned int **carr, jlongArray input) {
496   int i;
497   jsize sz;
498   if (!input) {
499     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
500     return 0;
501   }
502   sz = (*jenv)->GetArrayLength(jenv, input);
503   *jarr = (*jenv)->GetLongArrayElements(jenv, input, 0);
504   if (!*jarr)
505     return 0; 
506   *carr = (unsigned int*) malloc(sz * sizeof(unsigned int)); 
507   if (!*carr) {
508     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
509     return 0;
510   }
511   for (i=0; i<sz; i++)
512     (*carr)[i] = (unsigned int)(*jarr)[i];
513   return 1;
514 }
515
516 static void SWIG_JavaArrayArgoutUint (JNIEnv *jenv, jlong *jarr, unsigned int *carr, jlongArray input) {
517   int i;
518   jsize sz = (*jenv)->GetArrayLength(jenv, input);
519   for (i=0; i<sz; i++)
520     jarr[i] = (jlong)carr[i];
521   (*jenv)->ReleaseLongArrayElements(jenv, input, jarr, 0);
522 }
523
524 static jlongArray SWIG_JavaArrayOutUint (JNIEnv *jenv, unsigned int *result, jsize sz) {
525   jlong *arr;
526   int i;
527   jlongArray jresult = (*jenv)->NewLongArray(jenv, sz);
528   if (!jresult)
529     return NULL;
530   arr = (*jenv)->GetLongArrayElements(jenv, jresult, 0);
531   if (!arr)
532     return NULL;
533   for (i=0; i<sz; i++)
534     arr[i] = (jlong)result[i];
535   (*jenv)->ReleaseLongArrayElements(jenv, jresult, arr, 0);
536   return jresult;
537 }
538
539
540 /* long[] support */
541 static int SWIG_JavaArrayInLong (JNIEnv *jenv, jint **jarr, long **carr, jintArray input) {
542   int i;
543   jsize sz;
544   if (!input) {
545     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
546     return 0;
547   }
548   sz = (*jenv)->GetArrayLength(jenv, input);
549   *jarr = (*jenv)->GetIntArrayElements(jenv, input, 0);
550   if (!*jarr)
551     return 0; 
552   *carr = (long*) malloc(sz * sizeof(long)); 
553   if (!*carr) {
554     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
555     return 0;
556   }
557   for (i=0; i<sz; i++)
558     (*carr)[i] = (long)(*jarr)[i];
559   return 1;
560 }
561
562 static void SWIG_JavaArrayArgoutLong (JNIEnv *jenv, jint *jarr, long *carr, jintArray input) {
563   int i;
564   jsize sz = (*jenv)->GetArrayLength(jenv, input);
565   for (i=0; i<sz; i++)
566     jarr[i] = (jint)carr[i];
567   (*jenv)->ReleaseIntArrayElements(jenv, input, jarr, 0);
568 }
569
570 static jintArray SWIG_JavaArrayOutLong (JNIEnv *jenv, long *result, jsize sz) {
571   jint *arr;
572   int i;
573   jintArray jresult = (*jenv)->NewIntArray(jenv, sz);
574   if (!jresult)
575     return NULL;
576   arr = (*jenv)->GetIntArrayElements(jenv, jresult, 0);
577   if (!arr)
578     return NULL;
579   for (i=0; i<sz; i++)
580     arr[i] = (jint)result[i];
581   (*jenv)->ReleaseIntArrayElements(jenv, jresult, arr, 0);
582   return jresult;
583 }
584
585
586 /* unsigned long[] support */
587 static int SWIG_JavaArrayInUlong (JNIEnv *jenv, jlong **jarr, unsigned long **carr, jlongArray input) {
588   int i;
589   jsize sz;
590   if (!input) {
591     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
592     return 0;
593   }
594   sz = (*jenv)->GetArrayLength(jenv, input);
595   *jarr = (*jenv)->GetLongArrayElements(jenv, input, 0);
596   if (!*jarr)
597     return 0; 
598   *carr = (unsigned long*) malloc(sz * sizeof(unsigned long)); 
599   if (!*carr) {
600     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
601     return 0;
602   }
603   for (i=0; i<sz; i++)
604     (*carr)[i] = (unsigned long)(*jarr)[i];
605   return 1;
606 }
607
608 static void SWIG_JavaArrayArgoutUlong (JNIEnv *jenv, jlong *jarr, unsigned long *carr, jlongArray input) {
609   int i;
610   jsize sz = (*jenv)->GetArrayLength(jenv, input);
611   for (i=0; i<sz; i++)
612     jarr[i] = (jlong)carr[i];
613   (*jenv)->ReleaseLongArrayElements(jenv, input, jarr, 0);
614 }
615
616 static jlongArray SWIG_JavaArrayOutUlong (JNIEnv *jenv, unsigned long *result, jsize sz) {
617   jlong *arr;
618   int i;
619   jlongArray jresult = (*jenv)->NewLongArray(jenv, sz);
620   if (!jresult)
621     return NULL;
622   arr = (*jenv)->GetLongArrayElements(jenv, jresult, 0);
623   if (!arr)
624     return NULL;
625   for (i=0; i<sz; i++)
626     arr[i] = (jlong)result[i];
627   (*jenv)->ReleaseLongArrayElements(jenv, jresult, arr, 0);
628   return jresult;
629 }
630
631
632 /* jlong[] support */
633 static int SWIG_JavaArrayInLonglong (JNIEnv *jenv, jlong **jarr, jlong **carr, jlongArray input) {
634   int i;
635   jsize sz;
636   if (!input) {
637     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
638     return 0;
639   }
640   sz = (*jenv)->GetArrayLength(jenv, input);
641   *jarr = (*jenv)->GetLongArrayElements(jenv, input, 0);
642   if (!*jarr)
643     return 0; 
644   *carr = (jlong*) malloc(sz * sizeof(jlong)); 
645   if (!*carr) {
646     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
647     return 0;
648   }
649   for (i=0; i<sz; i++)
650     (*carr)[i] = (jlong)(*jarr)[i];
651   return 1;
652 }
653
654 static void SWIG_JavaArrayArgoutLonglong (JNIEnv *jenv, jlong *jarr, jlong *carr, jlongArray input) {
655   int i;
656   jsize sz = (*jenv)->GetArrayLength(jenv, input);
657   for (i=0; i<sz; i++)
658     jarr[i] = (jlong)carr[i];
659   (*jenv)->ReleaseLongArrayElements(jenv, input, jarr, 0);
660 }
661
662 static jlongArray SWIG_JavaArrayOutLonglong (JNIEnv *jenv, jlong *result, jsize sz) {
663   jlong *arr;
664   int i;
665   jlongArray jresult = (*jenv)->NewLongArray(jenv, sz);
666   if (!jresult)
667     return NULL;
668   arr = (*jenv)->GetLongArrayElements(jenv, jresult, 0);
669   if (!arr)
670     return NULL;
671   for (i=0; i<sz; i++)
672     arr[i] = (jlong)result[i];
673   (*jenv)->ReleaseLongArrayElements(jenv, jresult, arr, 0);
674   return jresult;
675 }
676
677
678 /* float[] support */
679 static int SWIG_JavaArrayInFloat (JNIEnv *jenv, jfloat **jarr, float **carr, jfloatArray input) {
680   int i;
681   jsize sz;
682   if (!input) {
683     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
684     return 0;
685   }
686   sz = (*jenv)->GetArrayLength(jenv, input);
687   *jarr = (*jenv)->GetFloatArrayElements(jenv, input, 0);
688   if (!*jarr)
689     return 0; 
690   *carr = (float*) malloc(sz * sizeof(float)); 
691   if (!*carr) {
692     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
693     return 0;
694   }
695   for (i=0; i<sz; i++)
696     (*carr)[i] = (float)(*jarr)[i];
697   return 1;
698 }
699
700 static void SWIG_JavaArrayArgoutFloat (JNIEnv *jenv, jfloat *jarr, float *carr, jfloatArray input) {
701   int i;
702   jsize sz = (*jenv)->GetArrayLength(jenv, input);
703   for (i=0; i<sz; i++)
704     jarr[i] = (jfloat)carr[i];
705   (*jenv)->ReleaseFloatArrayElements(jenv, input, jarr, 0);
706 }
707
708 static jfloatArray SWIG_JavaArrayOutFloat (JNIEnv *jenv, float *result, jsize sz) {
709   jfloat *arr;
710   int i;
711   jfloatArray jresult = (*jenv)->NewFloatArray(jenv, sz);
712   if (!jresult)
713     return NULL;
714   arr = (*jenv)->GetFloatArrayElements(jenv, jresult, 0);
715   if (!arr)
716     return NULL;
717   for (i=0; i<sz; i++)
718     arr[i] = (jfloat)result[i];
719   (*jenv)->ReleaseFloatArrayElements(jenv, jresult, arr, 0);
720   return jresult;
721 }
722
723
724 /* double[] support */
725 static int SWIG_JavaArrayInDouble (JNIEnv *jenv, jdouble **jarr, double **carr, jdoubleArray input) {
726   int i;
727   jsize sz;
728   if (!input) {
729     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
730     return 0;
731   }
732   sz = (*jenv)->GetArrayLength(jenv, input);
733   *jarr = (*jenv)->GetDoubleArrayElements(jenv, input, 0);
734   if (!*jarr)
735     return 0; 
736   *carr = (double*) malloc(sz * sizeof(double)); 
737   if (!*carr) {
738     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
739     return 0;
740   }
741   for (i=0; i<sz; i++)
742     (*carr)[i] = (double)(*jarr)[i];
743   return 1;
744 }
745
746 static void SWIG_JavaArrayArgoutDouble (JNIEnv *jenv, jdouble *jarr, double *carr, jdoubleArray input) {
747   int i;
748   jsize sz = (*jenv)->GetArrayLength(jenv, input);
749   for (i=0; i<sz; i++)
750     jarr[i] = (jdouble)carr[i];
751   (*jenv)->ReleaseDoubleArrayElements(jenv, input, jarr, 0);
752 }
753
754 static jdoubleArray SWIG_JavaArrayOutDouble (JNIEnv *jenv, double *result, jsize sz) {
755   jdouble *arr;
756   int i;
757   jdoubleArray jresult = (*jenv)->NewDoubleArray(jenv, sz);
758   if (!jresult)
759     return NULL;
760   arr = (*jenv)->GetDoubleArrayElements(jenv, jresult, 0);
761   if (!arr)
762     return NULL;
763   for (i=0; i<sz; i++)
764     arr[i] = (jdouble)result[i];
765   (*jenv)->ReleaseDoubleArrayElements(jenv, jresult, arr, 0);
766   return jresult;
767 }
768
769
770 #endif
771
772
773   #include "DataLoader.hxx"
774
775
776 #ifdef __cplusplus
777 extern "C" {
778 #endif
779
780 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_getTextureWidth(JNIEnv *jenv, jclass jcls, jint jarg1) {
781   jint jresult = 0 ;
782   int arg1 ;
783   int result;
784   
785   (void)jenv;
786   (void)jcls;
787   arg1 = (int)jarg1; 
788   result = (int)getTextureWidth(arg1);
789   jresult = (jint)result; 
790   return jresult;
791 }
792
793
794 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_getTextureHeight(JNIEnv *jenv, jclass jcls, jint jarg1) {
795   jint jresult = 0 ;
796   int arg1 ;
797   int result;
798   
799   (void)jenv;
800   (void)jcls;
801   arg1 = (int)jarg1; 
802   result = (int)getTextureHeight(arg1);
803   jresult = (jint)result; 
804   return jresult;
805 }
806
807
808 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_fillTextureData(JNIEnv *jenv, jclass jcls, jint jarg1, jobject jarg2, jint jarg3) {
809   jint jresult = 0 ;
810   int arg1 ;
811   unsigned char *arg2 = (unsigned char *) 0 ;
812   int arg3 ;
813   int result;
814   
815   (void)jenv;
816   (void)jcls;
817   arg1 = (int)jarg1; 
818   {
819     arg2 = (*jenv)->GetDirectBufferAddress(jenv, jarg2);
820     if (arg2 == NULL) {
821       SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
822     }
823   }
824   arg3 = (int)jarg3; 
825   result = (int)fillTextureData(arg1,arg2,arg3);
826   jresult = (jint)result; 
827   return jresult;
828 }
829
830
831 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) {
832   jint jresult = 0 ;
833   int arg1 ;
834   unsigned char *arg2 = (unsigned char *) 0 ;
835   int arg3 ;
836   int arg4 ;
837   int arg5 ;
838   int arg6 ;
839   int arg7 ;
840   int result;
841   
842   (void)jenv;
843   (void)jcls;
844   arg1 = (int)jarg1; 
845   {
846     arg2 = (*jenv)->GetDirectBufferAddress(jenv, jarg2);
847     if (arg2 == NULL) {
848       SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
849     }
850   }
851   arg3 = (int)jarg3; 
852   arg4 = (int)jarg4; 
853   arg5 = (int)jarg5; 
854   arg6 = (int)jarg6; 
855   arg7 = (int)jarg7; 
856   result = (int)fillSubTextureData(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
857   jresult = (jint)result; 
858   return jresult;
859 }
860
861
862 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_getDataSize(JNIEnv *jenv, jclass jcls, jint jarg1) {
863   jint jresult = 0 ;
864   int arg1 ;
865   int result;
866   
867   (void)jenv;
868   (void)jcls;
869   arg1 = (int)jarg1; 
870   result = (int)getDataSize(arg1);
871   jresult = (jint)result; 
872   return jresult;
873 }
874
875
876 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) {
877   int arg1 ;
878   float *arg2 = (float *) 0 ;
879   int arg3 ;
880   int arg4 ;
881   int arg5 ;
882   double *arg6 ;
883   double *arg7 ;
884   int arg8 ;
885   jdouble *jarr6 ;
886   jdouble *jarr7 ;
887   
888   (void)jenv;
889   (void)jcls;
890   arg1 = (int)jarg1; 
891   {
892     arg2 = (*jenv)->GetDirectBufferAddress(jenv, jarg2);
893     if (arg2 == NULL) {
894       SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
895     }
896   }
897   arg3 = (int)jarg3; 
898   arg4 = (int)jarg4; 
899   arg5 = (int)jarg5; 
900   if (!SWIG_JavaArrayInDouble(jenv, &jarr6, (double **)&arg6, jarg6)) return ; 
901   if (!SWIG_JavaArrayInDouble(jenv, &jarr7, (double **)&arg7, jarg7)) return ; 
902   arg8 = (int)jarg8; 
903   fillVertices(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
904   SWIG_JavaArrayArgoutDouble(jenv, jarr6, (double *)arg6, jarg6); 
905   SWIG_JavaArrayArgoutDouble(jenv, jarr7, (double *)arg7, jarg7); 
906   free(arg6); 
907   free(arg7); 
908 }
909
910
911 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) {
912   int arg1 ;
913   float *arg2 = (float *) 0 ;
914   float *arg3 = (float *) 0 ;
915   int arg4 ;
916   int arg5 ;
917   
918   (void)jenv;
919   (void)jcls;
920   arg1 = (int)jarg1; 
921   {
922     arg2 = (*jenv)->GetDirectBufferAddress(jenv, jarg2);
923     if (arg2 == NULL) {
924       SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
925     }
926   }
927   {
928     arg3 = (*jenv)->GetDirectBufferAddress(jenv, jarg3);
929     if (arg3 == NULL) {
930       SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
931     }
932   }
933   arg4 = (int)jarg4; 
934   arg5 = (int)jarg5; 
935   fillNormals(arg1,arg2,arg3,arg4,arg5);
936 }
937
938
939 SWIGEXPORT void JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_fillColors(JNIEnv *jenv, jclass jcls, jint jarg1, jobject jarg2, jint jarg3, jint jarg4) {
940   int arg1 ;
941   float *arg2 = (float *) 0 ;
942   int arg3 ;
943   int arg4 ;
944   
945   (void)jenv;
946   (void)jcls;
947   arg1 = (int)jarg1; 
948   {
949     arg2 = (*jenv)->GetDirectBufferAddress(jenv, jarg2);
950     if (arg2 == NULL) {
951       SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
952     }
953   }
954   arg3 = (int)jarg3; 
955   arg4 = (int)jarg4; 
956   fillColors(arg1,arg2,arg3,arg4);
957 }
958
959
960 SWIGEXPORT void JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_fillTextureCoordinates(JNIEnv *jenv, jclass jcls, jint jarg1, jobject jarg2, jint jarg3) {
961   int arg1 ;
962   float *arg2 = (float *) 0 ;
963   int arg3 ;
964   
965   (void)jenv;
966   (void)jcls;
967   arg1 = (int)jarg1; 
968   {
969     arg2 = (*jenv)->GetDirectBufferAddress(jenv, jarg2);
970     if (arg2 == NULL) {
971       SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
972     }
973   }
974   arg3 = (int)jarg3; 
975   fillTextureCoordinates(arg1,arg2,arg3);
976 }
977
978
979 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_getIndicesSize(JNIEnv *jenv, jclass jcls, jint jarg1) {
980   jint jresult = 0 ;
981   int arg1 ;
982   int result;
983   
984   (void)jenv;
985   (void)jcls;
986   arg1 = (int)jarg1; 
987   result = (int)getIndicesSize(arg1);
988   jresult = (jint)result; 
989   return jresult;
990 }
991
992
993 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_fillIndices(JNIEnv *jenv, jclass jcls, jint jarg1, jobject jarg2, jint jarg3, jint jarg4) {
994   jint jresult = 0 ;
995   int arg1 ;
996   int *arg2 = (int *) 0 ;
997   int arg3 ;
998   int arg4 ;
999   int result;
1000   
1001   (void)jenv;
1002   (void)jcls;
1003   arg1 = (int)jarg1; 
1004   {
1005     arg2 = (*jenv)->GetDirectBufferAddress(jenv, jarg2);
1006     if (arg2 == NULL) {
1007       SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
1008     }
1009   }
1010   arg3 = (int)jarg3; 
1011   arg4 = (int)jarg4; 
1012   result = (int)fillIndices(arg1,arg2,arg3,arg4);
1013   jresult = (jint)result; 
1014   return jresult;
1015 }
1016
1017
1018 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_getWireIndicesSize(JNIEnv *jenv, jclass jcls, jint jarg1) {
1019   jint jresult = 0 ;
1020   int arg1 ;
1021   int result;
1022   
1023   (void)jenv;
1024   (void)jcls;
1025   arg1 = (int)jarg1; 
1026   result = (int)getWireIndicesSize(arg1);
1027   jresult = (jint)result; 
1028   return jresult;
1029 }
1030
1031
1032 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_fillWireIndices(JNIEnv *jenv, jclass jcls, jint jarg1, jobject jarg2, jint jarg3, jint jarg4) {
1033   jint jresult = 0 ;
1034   int arg1 ;
1035   int *arg2 = (int *) 0 ;
1036   int arg3 ;
1037   int arg4 ;
1038   int result;
1039   
1040   (void)jenv;
1041   (void)jcls;
1042   arg1 = (int)jarg1; 
1043   {
1044     arg2 = (*jenv)->GetDirectBufferAddress(jenv, jarg2);
1045     if (arg2 == NULL) {
1046       SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
1047     }
1048   }
1049   arg3 = (int)jarg3; 
1050   arg4 = (int)jarg4; 
1051   result = (int)fillWireIndices(arg1,arg2,arg3,arg4);
1052   jresult = (jint)result; 
1053   return jresult;
1054 }
1055
1056
1057 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_getMarkIndicesSize(JNIEnv *jenv, jclass jcls, jint jarg1) {
1058   jint jresult = 0 ;
1059   int arg1 ;
1060   int result;
1061   
1062   (void)jenv;
1063   (void)jcls;
1064   arg1 = (int)jarg1; 
1065   result = (int)getMarkIndicesSize(arg1);
1066   jresult = (jint)result; 
1067   return jresult;
1068 }
1069
1070
1071 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_fillMarkIndices(JNIEnv *jenv, jclass jcls, jint jarg1, jobject jarg2, jint jarg3) {
1072   jint jresult = 0 ;
1073   int arg1 ;
1074   int *arg2 = (int *) 0 ;
1075   int arg3 ;
1076   int result;
1077   
1078   (void)jenv;
1079   (void)jcls;
1080   arg1 = (int)jarg1; 
1081   {
1082     arg2 = (*jenv)->GetDirectBufferAddress(jenv, jarg2);
1083     if (arg2 == NULL) {
1084       SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
1085     }
1086   }
1087   arg3 = (int)jarg3; 
1088   result = (int)fillMarkIndices(arg1,arg2,arg3);
1089   jresult = (jint)result; 
1090   return jresult;
1091 }
1092
1093
1094 SWIGEXPORT jobject JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_getTextureData(JNIEnv *jenv, jclass jcls, jint jarg1) {
1095   jobject jresult = 0 ;
1096   int arg1 ;
1097   JavaDirectBuffer result;
1098   
1099   (void)jenv;
1100   (void)jcls;
1101   arg1 = (int)jarg1; 
1102   result = getTextureData(arg1);
1103   {
1104     if ((&result)->address)
1105     {
1106       jresult = (*jenv)->NewDirectByteBuffer(jenv, (&result)->address, (&result)->size);
1107     }
1108   }
1109   return jresult;
1110 }
1111
1112
1113 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_getTextureImageType(JNIEnv *jenv, jclass jcls, jint jarg1) {
1114   jint jresult = 0 ;
1115   int arg1 ;
1116   int result;
1117   
1118   (void)jenv;
1119   (void)jcls;
1120   arg1 = (int)jarg1; 
1121   result = (int)getTextureImageType(arg1);
1122   jresult = (jint)result; 
1123   return jresult;
1124 }
1125
1126
1127 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_getTextureDataType(JNIEnv *jenv, jclass jcls, jint jarg1) {
1128   jint jresult = 0 ;
1129   int arg1 ;
1130   int result;
1131   
1132   (void)jenv;
1133   (void)jcls;
1134   arg1 = (int)jarg1; 
1135   result = (int)getTextureDataType(arg1);
1136   jresult = (jint)result; 
1137   return jresult;
1138 }
1139
1140
1141 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_getTextureGLType(JNIEnv *jenv, jclass jcls, jint jarg1) {
1142   jint jresult = 0 ;
1143   int arg1 ;
1144   int result;
1145   
1146   (void)jenv;
1147   (void)jcls;
1148   arg1 = (int)jarg1; 
1149   result = (int)getTextureGLType(arg1);
1150   jresult = (jint)result; 
1151   return jresult;
1152 }
1153
1154
1155 SWIGEXPORT void JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_disposeTextureData(JNIEnv *jenv, jclass jcls, jint jarg1, jobject jarg2) {
1156   int arg1 ;
1157   unsigned char *arg2 = (unsigned char *) 0 ;
1158   
1159   (void)jenv;
1160   (void)jcls;
1161   arg1 = (int)jarg1; 
1162   {
1163     arg2 = (*jenv)->GetDirectBufferAddress(jenv, jarg2);
1164     if (arg2 == NULL) {
1165       SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
1166     }
1167   }
1168   disposeTextureData(arg1,arg2);
1169 }
1170
1171
1172 SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_isTextureRowOrder(JNIEnv *jenv, jclass jcls, jint jarg1) {
1173   jint jresult = 0 ;
1174   int arg1 ;
1175   int result;
1176   
1177   (void)jenv;
1178   (void)jcls;
1179   arg1 = (int)jarg1; 
1180   result = (int)isTextureRowOrder(arg1);
1181   jresult = (jint)result; 
1182   return jresult;
1183 }
1184
1185
1186 SWIGEXPORT void JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_setABGRExt(JNIEnv *jenv, jclass jcls, jint jarg1) {
1187   int arg1 ;
1188   
1189   (void)jenv;
1190   (void)jcls;
1191   arg1 = (int)jarg1; 
1192   setABGRExt(arg1);
1193 }
1194
1195
1196 #ifdef __cplusplus
1197 }
1198 #endif
1199