JIMS: plug extraction
[scilab.git] / scilab / modules / external_objects_java / src / jni / ScilabJavaObject.cpp
1 #include "ScilabJavaObject.hxx"
2 /* Generated by GIWS (version 2.0.2) with command:
3 giws -e -r -f ScilabObjects.giws.xml
4 */
5 /*
6
7 This is generated code.
8
9 This software is a computer program whose purpose is to hide the complexity
10 of accessing Java objects/methods from C++ code.
11
12 This software is governed by the CeCILL-B license under French law and
13 abiding by the rules of distribution of free software.  You can  use,
14 modify and/ or redistribute the software under the terms of the CeCILL-B
15 license as circulated by CEA, CNRS and INRIA at the following URL
16 "http://www.cecill.info".
17
18 As a counterpart to the access to the source code and  rights to copy,
19 modify and redistribute granted by the license, users are provided only
20 with a limited warranty  and the software's author,  the holder of the
21 economic rights,  and the successive licensors  have only  limited
22 liability.
23
24 In this respect, the user's attention is drawn to the risks associated
25 with loading,  using,  modifying and/or developing or reproducing the
26 software by the user in light of its specific status of free software,
27 that may mean  that it is complicated to manipulate,  and  that  also
28 therefore means  that it is reserved for developers  and  experienced
29 professionals having in-depth computer knowledge. Users are therefore
30 encouraged to load and test the software's suitability as regards their
31 requirements in conditions enabling the security of their systems and/or
32 data to be ensured and,  more generally, to use and operate it in the
33 same conditions as regards security.
34
35 The fact that you are presently reading this means that you have had
36 knowledge of the CeCILL-B license and that you accept its terms.
37 */
38
39 namespace org_scilab_modules_external_objects_java
40 {
41
42 // Static declarations (if any)
43
44 // Returns the current env
45
46 JNIEnv * ScilabJavaObject::getCurrentEnv()
47 {
48     JNIEnv * curEnv = NULL;
49     jint res = this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
50     if (res != JNI_OK)
51     {
52         throw GiwsException::JniException(getCurrentEnv());
53     }
54     return curEnv;
55 }
56 // Destructor
57
58 ScilabJavaObject::~ScilabJavaObject()
59 {
60     JNIEnv * curEnv = NULL;
61     this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
62     curEnv->DeleteGlobalRef(this->instance);
63     curEnv->DeleteGlobalRef(this->instanceClass);
64     curEnv->DeleteGlobalRef(this->stringArrayClass);
65 }
66 // Constructors
67 ScilabJavaObject::ScilabJavaObject(JavaVM * jvm_)
68 {
69     jmethodID constructObject = NULL ;
70     jobject localInstance ;
71     jclass localClass ;
72
73     const std::string construct = "<init>";
74     const std::string param = "()V";
75     jvm = jvm_;
76
77     JNIEnv * curEnv = getCurrentEnv();
78
79     localClass = curEnv->FindClass( this->className().c_str() ) ;
80     if (localClass == NULL)
81     {
82         throw GiwsException::JniClassNotFoundException(curEnv, this->className());
83     }
84
85     this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
86
87     /* localClass is not needed anymore */
88     curEnv->DeleteLocalRef(localClass);
89
90     if (this->instanceClass == NULL)
91     {
92         throw GiwsException::JniObjectCreationException(curEnv, this->className());
93     }
94
95
96     constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
97     if (constructObject == NULL)
98     {
99         throw GiwsException::JniObjectCreationException(curEnv, this->className());
100     }
101
102     localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
103     if (localInstance == NULL)
104     {
105         throw GiwsException::JniObjectCreationException(curEnv, this->className());
106     }
107
108     this->instance = curEnv->NewGlobalRef(localInstance) ;
109     if (this->instance == NULL)
110     {
111         throw GiwsException::JniObjectCreationException(curEnv, this->className());
112     }
113     /* localInstance not needed anymore */
114     curEnv->DeleteLocalRef(localInstance);
115
116     /* Methods ID set to NULL */
117     jintinvokejintintjstringjava_lang_StringjintArray_intintID = NULL;
118     jintextractjintintjintArray_intintID = NULL;
119     voidinitScilabJavaObjectID = NULL;
120     voidgarbageCollectID = NULL;
121     jstringgetRepresentationjintintID = NULL;
122     jbooleanisValidJavaObjectjintintID = NULL;
123     voidenableTracejstringjava_lang_StringID = NULL;
124     voiddisableTraceID = NULL;
125     voidsetFieldjintintjstringjava_lang_StringjintintID = NULL;
126     jintgetFieldjintintjstringjava_lang_StringID = NULL;
127     jintgetFieldTypejintintjstringjava_lang_StringID = NULL;
128     jintjavaCastjintintjstringjava_lang_StringID = NULL;
129     jintjavaCastjintintjintintID = NULL;
130     jstringgetClassNamejintintID = NULL;
131     jintgetArrayElementjintintjintArray_intintID = NULL;
132     voidsetArrayElementjintintjintArray_intintjintintID = NULL;
133     voidremoveScilabJavaObjectjintintID = NULL;
134     voidlimitDirectBufferjintintID = NULL;
135     jintisUnwrappablejintintID = NULL;
136     jintwrapjdoubledoubleID = NULL;
137     jintwrapjdoubleArray_doubledoubleID = NULL;
138     jintwrapjobjectArray__doubledoubleID = NULL;
139     jintwrapjintintID = NULL;
140     jintwrapjintArray_intintID = NULL;
141     jintwrapjobjectArray__intintID = NULL;
142     jintwrapjbytebyteID = NULL;
143     jintwrapjbyteArray_bytebyteID = NULL;
144     jintwrapjobjectArray__bytebyteID = NULL;
145     jintwrapjshortshortID = NULL;
146     jintwrapjshortArray_shortshortID = NULL;
147     jintwrapjobjectArray__shortshortID = NULL;
148     jintwrapjstringjava_lang_StringID = NULL;
149     jintwrapjobjectArray_java_lang_Stringjava_lang_StringID = NULL;
150     jintwrapjobjectArray__java_lang_Stringjava_lang_StringID = NULL;
151     jintwrapjbooleanbooleanID = NULL;
152     jintwrapjbooleanArray_booleanbooleanID = NULL;
153     jintwrapjobjectArray__booleanbooleanID = NULL;
154     jintwrapjcharcharID = NULL;
155     jintwrapjcharArray_charcharID = NULL;
156     jintwrapjobjectArray__charcharID = NULL;
157     jintwrapjfloatfloatID = NULL;
158     jintwrapjfloatArray_floatfloatID = NULL;
159     jintwrapjobjectArray__floatfloatID = NULL;
160     jintwrapjlonglongID = NULL;
161     jintwrapjlongArray_longlongID = NULL;
162     jintwrapjobjectArray__longlongID = NULL;
163     jdoubleunwrapDoublejintintID = NULL;
164     jdoubleArray_unwrapRowDoublejintintID = NULL;
165     jobjectArray__unwrapMatDoublejintintID = NULL;
166     jintunwrapIntjintintID = NULL;
167     jintArray_unwrapRowIntjintintID = NULL;
168     jobjectArray__unwrapMatIntjintintID = NULL;
169     jlongunwrapUIntjintintID = NULL;
170     jlongArray_unwrapRowUIntjintintID = NULL;
171     jobjectArray__unwrapMatUIntjintintID = NULL;
172     jbyteunwrapBytejintintID = NULL;
173     jbyteArray_unwrapRowBytejintintID = NULL;
174     jobjectArray__unwrapMatBytejintintID = NULL;
175     jshortunwrapUBytejintintID = NULL;
176     jshortArray_unwrapRowUBytejintintID = NULL;
177     jobjectArray__unwrapMatUBytejintintID = NULL;
178     jshortunwrapShortjintintID = NULL;
179     jshortArray_unwrapRowShortjintintID = NULL;
180     jobjectArray__unwrapMatShortjintintID = NULL;
181     jintunwrapUShortjintintID = NULL;
182     jintArray_unwrapRowUShortjintintID = NULL;
183     jobjectArray__unwrapMatUShortjintintID = NULL;
184     jstringunwrapStringjintintID = NULL;
185     jobjectArray_unwrapRowStringjintintID = NULL;
186     jobjectArray__unwrapMatStringjintintID = NULL;
187     jbooleanunwrapBooleanjintintID = NULL;
188     jbooleanArray_unwrapRowBooleanjintintID = NULL;
189     jobjectArray__unwrapMatBooleanjintintID = NULL;
190     jcharunwrapCharjintintID = NULL;
191     jcharArray_unwrapRowCharjintintID = NULL;
192     jobjectArray__unwrapMatCharjintintID = NULL;
193     jfloatunwrapFloatjintintID = NULL;
194     jfloatArray_unwrapRowFloatjintintID = NULL;
195     jobjectArray__unwrapMatFloatjintintID = NULL;
196     jlongunwrapLongjintintID = NULL;
197     jlongArray_unwrapRowLongjintintID = NULL;
198     jobjectArray__unwrapMatLongjintintID = NULL;
199
200
201 }
202
203 ScilabJavaObject::ScilabJavaObject(JavaVM * jvm_, jobject JObj)
204 {
205     jvm = jvm_;
206
207     JNIEnv * curEnv = getCurrentEnv();
208
209     jclass localClass = curEnv->GetObjectClass(JObj);
210     this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
211     curEnv->DeleteLocalRef(localClass);
212
213     if (this->instanceClass == NULL)
214     {
215         throw GiwsException::JniObjectCreationException(curEnv, this->className());
216     }
217
218     this->instance = curEnv->NewGlobalRef(JObj) ;
219     if (this->instance == NULL)
220     {
221         throw GiwsException::JniObjectCreationException(curEnv, this->className());
222     }
223     /* Methods ID set to NULL */
224     jintinvokejintintjstringjava_lang_StringjintArray_intintID = NULL;
225     jintextractjintintjintArray_intintID = NULL;
226     voidinitScilabJavaObjectID = NULL;
227     voidgarbageCollectID = NULL;
228     jstringgetRepresentationjintintID = NULL;
229     jbooleanisValidJavaObjectjintintID = NULL;
230     voidenableTracejstringjava_lang_StringID = NULL;
231     voiddisableTraceID = NULL;
232     voidsetFieldjintintjstringjava_lang_StringjintintID = NULL;
233     jintgetFieldjintintjstringjava_lang_StringID = NULL;
234     jintgetFieldTypejintintjstringjava_lang_StringID = NULL;
235     jintjavaCastjintintjstringjava_lang_StringID = NULL;
236     jintjavaCastjintintjintintID = NULL;
237     jstringgetClassNamejintintID = NULL;
238     jintgetArrayElementjintintjintArray_intintID = NULL;
239     voidsetArrayElementjintintjintArray_intintjintintID = NULL;
240     voidremoveScilabJavaObjectjintintID = NULL;
241     voidlimitDirectBufferjintintID = NULL;
242     jintisUnwrappablejintintID = NULL;
243     jintwrapjdoubledoubleID = NULL;
244     jintwrapjdoubleArray_doubledoubleID = NULL;
245     jintwrapjobjectArray__doubledoubleID = NULL;
246     jintwrapjintintID = NULL;
247     jintwrapjintArray_intintID = NULL;
248     jintwrapjobjectArray__intintID = NULL;
249     jintwrapjbytebyteID = NULL;
250     jintwrapjbyteArray_bytebyteID = NULL;
251     jintwrapjobjectArray__bytebyteID = NULL;
252     jintwrapjshortshortID = NULL;
253     jintwrapjshortArray_shortshortID = NULL;
254     jintwrapjobjectArray__shortshortID = NULL;
255     jintwrapjstringjava_lang_StringID = NULL;
256     jintwrapjobjectArray_java_lang_Stringjava_lang_StringID = NULL;
257     jintwrapjobjectArray__java_lang_Stringjava_lang_StringID = NULL;
258     jintwrapjbooleanbooleanID = NULL;
259     jintwrapjbooleanArray_booleanbooleanID = NULL;
260     jintwrapjobjectArray__booleanbooleanID = NULL;
261     jintwrapjcharcharID = NULL;
262     jintwrapjcharArray_charcharID = NULL;
263     jintwrapjobjectArray__charcharID = NULL;
264     jintwrapjfloatfloatID = NULL;
265     jintwrapjfloatArray_floatfloatID = NULL;
266     jintwrapjobjectArray__floatfloatID = NULL;
267     jintwrapjlonglongID = NULL;
268     jintwrapjlongArray_longlongID = NULL;
269     jintwrapjobjectArray__longlongID = NULL;
270     jdoubleunwrapDoublejintintID = NULL;
271     jdoubleArray_unwrapRowDoublejintintID = NULL;
272     jobjectArray__unwrapMatDoublejintintID = NULL;
273     jintunwrapIntjintintID = NULL;
274     jintArray_unwrapRowIntjintintID = NULL;
275     jobjectArray__unwrapMatIntjintintID = NULL;
276     jlongunwrapUIntjintintID = NULL;
277     jlongArray_unwrapRowUIntjintintID = NULL;
278     jobjectArray__unwrapMatUIntjintintID = NULL;
279     jbyteunwrapBytejintintID = NULL;
280     jbyteArray_unwrapRowBytejintintID = NULL;
281     jobjectArray__unwrapMatBytejintintID = NULL;
282     jshortunwrapUBytejintintID = NULL;
283     jshortArray_unwrapRowUBytejintintID = NULL;
284     jobjectArray__unwrapMatUBytejintintID = NULL;
285     jshortunwrapShortjintintID = NULL;
286     jshortArray_unwrapRowShortjintintID = NULL;
287     jobjectArray__unwrapMatShortjintintID = NULL;
288     jintunwrapUShortjintintID = NULL;
289     jintArray_unwrapRowUShortjintintID = NULL;
290     jobjectArray__unwrapMatUShortjintintID = NULL;
291     jstringunwrapStringjintintID = NULL;
292     jobjectArray_unwrapRowStringjintintID = NULL;
293     jobjectArray__unwrapMatStringjintintID = NULL;
294     jbooleanunwrapBooleanjintintID = NULL;
295     jbooleanArray_unwrapRowBooleanjintintID = NULL;
296     jobjectArray__unwrapMatBooleanjintintID = NULL;
297     jcharunwrapCharjintintID = NULL;
298     jcharArray_unwrapRowCharjintintID = NULL;
299     jobjectArray__unwrapMatCharjintintID = NULL;
300     jfloatunwrapFloatjintintID = NULL;
301     jfloatArray_unwrapRowFloatjintintID = NULL;
302     jobjectArray__unwrapMatFloatjintintID = NULL;
303     jlongunwrapLongjintintID = NULL;
304     jlongArray_unwrapRowLongjintintID = NULL;
305     jobjectArray__unwrapMatLongjintintID = NULL;
306
307
308 }
309
310 // Generic methods
311
312 void ScilabJavaObject::synchronize()
313 {
314     if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK)
315     {
316         throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaObject");
317     }
318 }
319
320 void ScilabJavaObject::endSynchronize()
321 {
322     if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK)
323     {
324         throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaObject");
325     }
326 }
327 // Method(s)
328
329 int ScilabJavaObject::invoke (JavaVM * jvm_, int id, char const* methodName, int const* args, int argsSize)
330 {
331
332     JNIEnv * curEnv = NULL;
333     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
334     jclass cls = curEnv->FindClass( className().c_str() );
335     if ( cls == NULL)
336     {
337         throw GiwsException::JniCallMethodException(curEnv);
338     }
339
340     jmethodID jintinvokejintintjstringjava_lang_StringjintArray_intintID = curEnv->GetStaticMethodID(cls, "invoke", "(ILjava/lang/String;[I)I" ) ;
341     if (jintinvokejintintjstringjava_lang_StringjintArray_intintID == NULL)
342     {
343         throw GiwsException::JniMethodNotFoundException(curEnv, "invoke");
344     }
345
346     jstring methodName_ = curEnv->NewStringUTF( methodName );
347     if (methodName != NULL && methodName_ == NULL)
348     {
349         throw GiwsException::JniBadAllocException(curEnv);
350     }
351
352
353     jintArray args_ = curEnv->NewIntArray( argsSize ) ;
354
355     if (args_ == NULL)
356     {
357         // check that allocation succeed
358         throw GiwsException::JniBadAllocException(curEnv);
359     }
360
361     curEnv->SetIntArrayRegion( args_, 0, argsSize, (jint*)(args) ) ;
362
363
364     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintinvokejintintjstringjava_lang_StringjintArray_intintID , id, methodName_, args_));
365     curEnv->DeleteLocalRef(methodName_);
366     curEnv->DeleteLocalRef(args_);
367     curEnv->DeleteLocalRef(cls);
368     if (curEnv->ExceptionCheck())
369     {
370         throw GiwsException::JniCallMethodException(curEnv);
371     }
372     return res;
373
374 }
375
376 int ScilabJavaObject::extract (JavaVM * jvm_, int id, int const* args, int argsSize)
377 {
378
379     JNIEnv * curEnv = NULL;
380     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
381     jclass cls = curEnv->FindClass( className().c_str() );
382     if ( cls == NULL)
383     {
384         throw GiwsException::JniCallMethodException(curEnv);
385     }
386
387     jmethodID jintextractjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "extract", "(I[I)I" ) ;
388     if (jintextractjintintjintArray_intintID == NULL)
389     {
390         throw GiwsException::JniMethodNotFoundException(curEnv, "extract");
391     }
392
393     jintArray args_ = curEnv->NewIntArray( argsSize ) ;
394
395     if (args_ == NULL)
396     {
397         // check that allocation succeed
398         throw GiwsException::JniBadAllocException(curEnv);
399     }
400
401     curEnv->SetIntArrayRegion( args_, 0, argsSize, (jint*)(args) ) ;
402
403
404     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintextractjintintjintArray_intintID , id, args_));
405     curEnv->DeleteLocalRef(args_);
406     curEnv->DeleteLocalRef(cls);
407     if (curEnv->ExceptionCheck())
408     {
409         throw GiwsException::JniCallMethodException(curEnv);
410     }
411     return res;
412
413 }
414
415 void ScilabJavaObject::initScilabJavaObject (JavaVM * jvm_)
416 {
417
418     JNIEnv * curEnv = NULL;
419     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
420     jclass cls = curEnv->FindClass( className().c_str() );
421     if ( cls == NULL)
422     {
423         throw GiwsException::JniCallMethodException(curEnv);
424     }
425
426     jmethodID voidinitScilabJavaObjectID = curEnv->GetStaticMethodID(cls, "initScilabJavaObject", "()V" ) ;
427     if (voidinitScilabJavaObjectID == NULL)
428     {
429         throw GiwsException::JniMethodNotFoundException(curEnv, "initScilabJavaObject");
430     }
431
432     curEnv->CallStaticVoidMethod(cls, voidinitScilabJavaObjectID );
433     curEnv->DeleteLocalRef(cls);
434     if (curEnv->ExceptionCheck())
435     {
436         throw GiwsException::JniCallMethodException(curEnv);
437     }
438 }
439
440 void ScilabJavaObject::garbageCollect (JavaVM * jvm_)
441 {
442
443     JNIEnv * curEnv = NULL;
444     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
445     jclass cls = curEnv->FindClass( className().c_str() );
446     if ( cls == NULL)
447     {
448         throw GiwsException::JniCallMethodException(curEnv);
449     }
450
451     jmethodID voidgarbageCollectID = curEnv->GetStaticMethodID(cls, "garbageCollect", "()V" ) ;
452     if (voidgarbageCollectID == NULL)
453     {
454         throw GiwsException::JniMethodNotFoundException(curEnv, "garbageCollect");
455     }
456
457     curEnv->CallStaticVoidMethod(cls, voidgarbageCollectID );
458     curEnv->DeleteLocalRef(cls);
459     if (curEnv->ExceptionCheck())
460     {
461         throw GiwsException::JniCallMethodException(curEnv);
462     }
463 }
464
465 char* ScilabJavaObject::getRepresentation (JavaVM * jvm_, int id)
466 {
467
468     JNIEnv * curEnv = NULL;
469     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
470     jclass cls = curEnv->FindClass( className().c_str() );
471     if ( cls == NULL)
472     {
473         throw GiwsException::JniCallMethodException(curEnv);
474     }
475
476     jmethodID jstringgetRepresentationjintintID = curEnv->GetStaticMethodID(cls, "getRepresentation", "(I)Ljava/lang/String;" ) ;
477     if (jstringgetRepresentationjintintID == NULL)
478     {
479         throw GiwsException::JniMethodNotFoundException(curEnv, "getRepresentation");
480     }
481
482     jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringgetRepresentationjintintID , id));
483     if (curEnv->ExceptionCheck())
484     {
485         throw GiwsException::JniCallMethodException(curEnv);
486     }
487     if (res != NULL)
488     {
489
490         const char *tempString = curEnv->GetStringUTFChars(res, 0);
491         char * myStringBuffer = new char[strlen(tempString) + 1];
492         strcpy(myStringBuffer, tempString);
493         curEnv->ReleaseStringUTFChars(res, tempString);
494         curEnv->DeleteLocalRef(res);
495         curEnv->DeleteLocalRef(cls);
496         if (curEnv->ExceptionCheck())
497         {
498             delete[] myStringBuffer;
499             throw GiwsException::JniCallMethodException(curEnv);
500         }
501         return myStringBuffer;
502     }
503     else
504     {
505         curEnv->DeleteLocalRef(res);
506         return NULL;
507     }
508 }
509
510 bool ScilabJavaObject::isValidJavaObject (JavaVM * jvm_, int id)
511 {
512
513     JNIEnv * curEnv = NULL;
514     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
515     jclass cls = curEnv->FindClass( className().c_str() );
516     if ( cls == NULL)
517     {
518         throw GiwsException::JniCallMethodException(curEnv);
519     }
520
521     jmethodID jbooleanisValidJavaObjectjintintID = curEnv->GetStaticMethodID(cls, "isValidJavaObject", "(I)Z" ) ;
522     if (jbooleanisValidJavaObjectjintintID == NULL)
523     {
524         throw GiwsException::JniMethodNotFoundException(curEnv, "isValidJavaObject");
525     }
526
527     jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanisValidJavaObjectjintintID , id));
528     curEnv->DeleteLocalRef(cls);
529     if (curEnv->ExceptionCheck())
530     {
531         throw GiwsException::JniCallMethodException(curEnv);
532     }
533     return (res == JNI_TRUE);
534
535 }
536
537 void ScilabJavaObject::enableTrace (JavaVM * jvm_, char const* filename)
538 {
539
540     JNIEnv * curEnv = NULL;
541     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
542     jclass cls = curEnv->FindClass( className().c_str() );
543     if ( cls == NULL)
544     {
545         throw GiwsException::JniCallMethodException(curEnv);
546     }
547
548     jmethodID voidenableTracejstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "enableTrace", "(Ljava/lang/String;)V" ) ;
549     if (voidenableTracejstringjava_lang_StringID == NULL)
550     {
551         throw GiwsException::JniMethodNotFoundException(curEnv, "enableTrace");
552     }
553
554     jstring filename_ = curEnv->NewStringUTF( filename );
555     if (filename != NULL && filename_ == NULL)
556     {
557         throw GiwsException::JniBadAllocException(curEnv);
558     }
559
560
561     curEnv->CallStaticVoidMethod(cls, voidenableTracejstringjava_lang_StringID , filename_);
562     curEnv->DeleteLocalRef(filename_);
563     curEnv->DeleteLocalRef(cls);
564     if (curEnv->ExceptionCheck())
565     {
566         throw GiwsException::JniCallMethodException(curEnv);
567     }
568 }
569
570 void ScilabJavaObject::disableTrace (JavaVM * jvm_)
571 {
572
573     JNIEnv * curEnv = NULL;
574     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
575     jclass cls = curEnv->FindClass( className().c_str() );
576     if ( cls == NULL)
577     {
578         throw GiwsException::JniCallMethodException(curEnv);
579     }
580
581     jmethodID voiddisableTraceID = curEnv->GetStaticMethodID(cls, "disableTrace", "()V" ) ;
582     if (voiddisableTraceID == NULL)
583     {
584         throw GiwsException::JniMethodNotFoundException(curEnv, "disableTrace");
585     }
586
587     curEnv->CallStaticVoidMethod(cls, voiddisableTraceID );
588     curEnv->DeleteLocalRef(cls);
589     if (curEnv->ExceptionCheck())
590     {
591         throw GiwsException::JniCallMethodException(curEnv);
592     }
593 }
594
595 void ScilabJavaObject::setField (JavaVM * jvm_, int id, char const* fieldName, int idarg)
596 {
597
598     JNIEnv * curEnv = NULL;
599     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
600     jclass cls = curEnv->FindClass( className().c_str() );
601     if ( cls == NULL)
602     {
603         throw GiwsException::JniCallMethodException(curEnv);
604     }
605
606     jmethodID voidsetFieldjintintjstringjava_lang_StringjintintID = curEnv->GetStaticMethodID(cls, "setField", "(ILjava/lang/String;I)V" ) ;
607     if (voidsetFieldjintintjstringjava_lang_StringjintintID == NULL)
608     {
609         throw GiwsException::JniMethodNotFoundException(curEnv, "setField");
610     }
611
612     jstring fieldName_ = curEnv->NewStringUTF( fieldName );
613     if (fieldName != NULL && fieldName_ == NULL)
614     {
615         throw GiwsException::JniBadAllocException(curEnv);
616     }
617
618
619     curEnv->CallStaticVoidMethod(cls, voidsetFieldjintintjstringjava_lang_StringjintintID , id, fieldName_, idarg);
620     curEnv->DeleteLocalRef(fieldName_);
621     curEnv->DeleteLocalRef(cls);
622     if (curEnv->ExceptionCheck())
623     {
624         throw GiwsException::JniCallMethodException(curEnv);
625     }
626 }
627
628 int ScilabJavaObject::getField (JavaVM * jvm_, int id, char const* fieldName)
629 {
630
631     JNIEnv * curEnv = NULL;
632     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
633     jclass cls = curEnv->FindClass( className().c_str() );
634     if ( cls == NULL)
635     {
636         throw GiwsException::JniCallMethodException(curEnv);
637     }
638
639     jmethodID jintgetFieldjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "getField", "(ILjava/lang/String;)I" ) ;
640     if (jintgetFieldjintintjstringjava_lang_StringID == NULL)
641     {
642         throw GiwsException::JniMethodNotFoundException(curEnv, "getField");
643     }
644
645     jstring fieldName_ = curEnv->NewStringUTF( fieldName );
646     if (fieldName != NULL && fieldName_ == NULL)
647     {
648         throw GiwsException::JniBadAllocException(curEnv);
649     }
650
651
652     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetFieldjintintjstringjava_lang_StringID , id, fieldName_));
653     curEnv->DeleteLocalRef(fieldName_);
654     curEnv->DeleteLocalRef(cls);
655     if (curEnv->ExceptionCheck())
656     {
657         throw GiwsException::JniCallMethodException(curEnv);
658     }
659     return res;
660
661 }
662
663 int ScilabJavaObject::getFieldType (JavaVM * jvm_, int id, char const* fieldName)
664 {
665
666     JNIEnv * curEnv = NULL;
667     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
668     jclass cls = curEnv->FindClass( className().c_str() );
669     if ( cls == NULL)
670     {
671         throw GiwsException::JniCallMethodException(curEnv);
672     }
673
674     jmethodID jintgetFieldTypejintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "getFieldType", "(ILjava/lang/String;)I" ) ;
675     if (jintgetFieldTypejintintjstringjava_lang_StringID == NULL)
676     {
677         throw GiwsException::JniMethodNotFoundException(curEnv, "getFieldType");
678     }
679
680     jstring fieldName_ = curEnv->NewStringUTF( fieldName );
681     if (fieldName != NULL && fieldName_ == NULL)
682     {
683         throw GiwsException::JniBadAllocException(curEnv);
684     }
685
686
687     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetFieldTypejintintjstringjava_lang_StringID , id, fieldName_));
688     curEnv->DeleteLocalRef(fieldName_);
689     curEnv->DeleteLocalRef(cls);
690     if (curEnv->ExceptionCheck())
691     {
692         throw GiwsException::JniCallMethodException(curEnv);
693     }
694     return res;
695
696 }
697
698 int ScilabJavaObject::javaCast (JavaVM * jvm_, int id, char const* objName)
699 {
700
701     JNIEnv * curEnv = NULL;
702     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
703     jclass cls = curEnv->FindClass( className().c_str() );
704     if ( cls == NULL)
705     {
706         throw GiwsException::JniCallMethodException(curEnv);
707     }
708
709     jmethodID jintjavaCastjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "javaCast", "(ILjava/lang/String;)I" ) ;
710     if (jintjavaCastjintintjstringjava_lang_StringID == NULL)
711     {
712         throw GiwsException::JniMethodNotFoundException(curEnv, "javaCast");
713     }
714
715     jstring objName_ = curEnv->NewStringUTF( objName );
716     if (objName != NULL && objName_ == NULL)
717     {
718         throw GiwsException::JniBadAllocException(curEnv);
719     }
720
721
722     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintjavaCastjintintjstringjava_lang_StringID , id, objName_));
723     curEnv->DeleteLocalRef(objName_);
724     curEnv->DeleteLocalRef(cls);
725     if (curEnv->ExceptionCheck())
726     {
727         throw GiwsException::JniCallMethodException(curEnv);
728     }
729     return res;
730
731 }
732
733 int ScilabJavaObject::javaCast (JavaVM * jvm_, int id, int classId)
734 {
735
736     JNIEnv * curEnv = NULL;
737     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
738     jclass cls = curEnv->FindClass( className().c_str() );
739     if ( cls == NULL)
740     {
741         throw GiwsException::JniCallMethodException(curEnv);
742     }
743
744     jmethodID jintjavaCastjintintjintintID = curEnv->GetStaticMethodID(cls, "javaCast", "(II)I" ) ;
745     if (jintjavaCastjintintjintintID == NULL)
746     {
747         throw GiwsException::JniMethodNotFoundException(curEnv, "javaCast");
748     }
749
750     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintjavaCastjintintjintintID , id, classId));
751     curEnv->DeleteLocalRef(cls);
752     if (curEnv->ExceptionCheck())
753     {
754         throw GiwsException::JniCallMethodException(curEnv);
755     }
756     return res;
757
758 }
759
760 char* ScilabJavaObject::getClassName (JavaVM * jvm_, int id)
761 {
762
763     JNIEnv * curEnv = NULL;
764     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
765     jclass cls = curEnv->FindClass( className().c_str() );
766     if ( cls == NULL)
767     {
768         throw GiwsException::JniCallMethodException(curEnv);
769     }
770
771     jmethodID jstringgetClassNamejintintID = curEnv->GetStaticMethodID(cls, "getClassName", "(I)Ljava/lang/String;" ) ;
772     if (jstringgetClassNamejintintID == NULL)
773     {
774         throw GiwsException::JniMethodNotFoundException(curEnv, "getClassName");
775     }
776
777     jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringgetClassNamejintintID , id));
778     if (curEnv->ExceptionCheck())
779     {
780         throw GiwsException::JniCallMethodException(curEnv);
781     }
782     if (res != NULL)
783     {
784
785         const char *tempString = curEnv->GetStringUTFChars(res, 0);
786         char * myStringBuffer = new char[strlen(tempString) + 1];
787         strcpy(myStringBuffer, tempString);
788         curEnv->ReleaseStringUTFChars(res, tempString);
789         curEnv->DeleteLocalRef(res);
790         curEnv->DeleteLocalRef(cls);
791         if (curEnv->ExceptionCheck())
792         {
793             delete[] myStringBuffer;
794             throw GiwsException::JniCallMethodException(curEnv);
795         }
796         return myStringBuffer;
797     }
798     else
799     {
800         curEnv->DeleteLocalRef(res);
801         return NULL;
802     }
803 }
804
805 int ScilabJavaObject::getArrayElement (JavaVM * jvm_, int id, int const* index, int indexSize)
806 {
807
808     JNIEnv * curEnv = NULL;
809     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
810     jclass cls = curEnv->FindClass( className().c_str() );
811     if ( cls == NULL)
812     {
813         throw GiwsException::JniCallMethodException(curEnv);
814     }
815
816     jmethodID jintgetArrayElementjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "getArrayElement", "(I[I)I" ) ;
817     if (jintgetArrayElementjintintjintArray_intintID == NULL)
818     {
819         throw GiwsException::JniMethodNotFoundException(curEnv, "getArrayElement");
820     }
821
822     jintArray index_ = curEnv->NewIntArray( indexSize ) ;
823
824     if (index_ == NULL)
825     {
826         // check that allocation succeed
827         throw GiwsException::JniBadAllocException(curEnv);
828     }
829
830     curEnv->SetIntArrayRegion( index_, 0, indexSize, (jint*)(index) ) ;
831
832
833     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetArrayElementjintintjintArray_intintID , id, index_));
834     curEnv->DeleteLocalRef(index_);
835     curEnv->DeleteLocalRef(cls);
836     if (curEnv->ExceptionCheck())
837     {
838         throw GiwsException::JniCallMethodException(curEnv);
839     }
840     return res;
841
842 }
843
844 void ScilabJavaObject::setArrayElement (JavaVM * jvm_, int id, int const* index, int indexSize, int idArg)
845 {
846
847     JNIEnv * curEnv = NULL;
848     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
849     jclass cls = curEnv->FindClass( className().c_str() );
850     if ( cls == NULL)
851     {
852         throw GiwsException::JniCallMethodException(curEnv);
853     }
854
855     jmethodID voidsetArrayElementjintintjintArray_intintjintintID = curEnv->GetStaticMethodID(cls, "setArrayElement", "(I[II)V" ) ;
856     if (voidsetArrayElementjintintjintArray_intintjintintID == NULL)
857     {
858         throw GiwsException::JniMethodNotFoundException(curEnv, "setArrayElement");
859     }
860
861     jintArray index_ = curEnv->NewIntArray( indexSize ) ;
862
863     if (index_ == NULL)
864     {
865         // check that allocation succeed
866         throw GiwsException::JniBadAllocException(curEnv);
867     }
868
869     curEnv->SetIntArrayRegion( index_, 0, indexSize, (jint*)(index) ) ;
870
871
872     curEnv->CallStaticVoidMethod(cls, voidsetArrayElementjintintjintArray_intintjintintID , id, index_, idArg);
873     curEnv->DeleteLocalRef(index_);
874     curEnv->DeleteLocalRef(cls);
875     if (curEnv->ExceptionCheck())
876     {
877         throw GiwsException::JniCallMethodException(curEnv);
878     }
879 }
880
881 void ScilabJavaObject::removeScilabJavaObject (JavaVM * jvm_, int id)
882 {
883
884     JNIEnv * curEnv = NULL;
885     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
886     jclass cls = curEnv->FindClass( className().c_str() );
887     if ( cls == NULL)
888     {
889         throw GiwsException::JniCallMethodException(curEnv);
890     }
891
892     jmethodID voidremoveScilabJavaObjectjintintID = curEnv->GetStaticMethodID(cls, "removeScilabJavaObject", "(I)V" ) ;
893     if (voidremoveScilabJavaObjectjintintID == NULL)
894     {
895         throw GiwsException::JniMethodNotFoundException(curEnv, "removeScilabJavaObject");
896     }
897
898     curEnv->CallStaticVoidMethod(cls, voidremoveScilabJavaObjectjintintID , id);
899     curEnv->DeleteLocalRef(cls);
900     if (curEnv->ExceptionCheck())
901     {
902         throw GiwsException::JniCallMethodException(curEnv);
903     }
904 }
905
906 void ScilabJavaObject::limitDirectBuffer (JavaVM * jvm_, int id)
907 {
908
909     JNIEnv * curEnv = NULL;
910     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
911     jclass cls = curEnv->FindClass( className().c_str() );
912     if ( cls == NULL)
913     {
914         throw GiwsException::JniCallMethodException(curEnv);
915     }
916
917     jmethodID voidlimitDirectBufferjintintID = curEnv->GetStaticMethodID(cls, "limitDirectBuffer", "(I)V" ) ;
918     if (voidlimitDirectBufferjintintID == NULL)
919     {
920         throw GiwsException::JniMethodNotFoundException(curEnv, "limitDirectBuffer");
921     }
922
923     curEnv->CallStaticVoidMethod(cls, voidlimitDirectBufferjintintID , id);
924     curEnv->DeleteLocalRef(cls);
925     if (curEnv->ExceptionCheck())
926     {
927         throw GiwsException::JniCallMethodException(curEnv);
928     }
929 }
930
931 int ScilabJavaObject::isUnwrappable (JavaVM * jvm_, int id)
932 {
933
934     JNIEnv * curEnv = NULL;
935     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
936     jclass cls = curEnv->FindClass( className().c_str() );
937     if ( cls == NULL)
938     {
939         throw GiwsException::JniCallMethodException(curEnv);
940     }
941
942     jmethodID jintisUnwrappablejintintID = curEnv->GetStaticMethodID(cls, "isUnwrappable", "(I)I" ) ;
943     if (jintisUnwrappablejintintID == NULL)
944     {
945         throw GiwsException::JniMethodNotFoundException(curEnv, "isUnwrappable");
946     }
947
948     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintisUnwrappablejintintID , id));
949     curEnv->DeleteLocalRef(cls);
950     if (curEnv->ExceptionCheck())
951     {
952         throw GiwsException::JniCallMethodException(curEnv);
953     }
954     return res;
955
956 }
957
958 int ScilabJavaObject::wrap (JavaVM * jvm_, double x)
959 {
960
961     JNIEnv * curEnv = NULL;
962     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
963     jclass cls = curEnv->FindClass( className().c_str() );
964     if ( cls == NULL)
965     {
966         throw GiwsException::JniCallMethodException(curEnv);
967     }
968
969     jmethodID jintwrapjdoubledoubleID = curEnv->GetStaticMethodID(cls, "wrap", "(D)I" ) ;
970     if (jintwrapjdoubledoubleID == NULL)
971     {
972         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
973     }
974
975     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjdoubledoubleID , x));
976     curEnv->DeleteLocalRef(cls);
977     if (curEnv->ExceptionCheck())
978     {
979         throw GiwsException::JniCallMethodException(curEnv);
980     }
981     return res;
982
983 }
984
985 int ScilabJavaObject::wrap (JavaVM * jvm_, double const* x, int xSize)
986 {
987
988     JNIEnv * curEnv = NULL;
989     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
990     jclass cls = curEnv->FindClass( className().c_str() );
991     if ( cls == NULL)
992     {
993         throw GiwsException::JniCallMethodException(curEnv);
994     }
995
996     jmethodID jintwrapjdoubleArray_doubledoubleID = curEnv->GetStaticMethodID(cls, "wrap", "([D)I" ) ;
997     if (jintwrapjdoubleArray_doubledoubleID == NULL)
998     {
999         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1000     }
1001
1002     jdoubleArray x_ = curEnv->NewDoubleArray( xSize ) ;
1003
1004     if (x_ == NULL)
1005     {
1006         // check that allocation succeed
1007         throw GiwsException::JniBadAllocException(curEnv);
1008     }
1009
1010     curEnv->SetDoubleArrayRegion( x_, 0, xSize, (jdouble*)(x) ) ;
1011
1012
1013     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjdoubleArray_doubledoubleID , x_));
1014     curEnv->DeleteLocalRef(x_);
1015     curEnv->DeleteLocalRef(cls);
1016     if (curEnv->ExceptionCheck())
1017     {
1018         throw GiwsException::JniCallMethodException(curEnv);
1019     }
1020     return res;
1021
1022 }
1023
1024 int ScilabJavaObject::wrap (JavaVM * jvm_, double const* const* x, int xSize, int xSizeCol)
1025 {
1026
1027     JNIEnv * curEnv = NULL;
1028     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1029     jclass cls = curEnv->FindClass( className().c_str() );
1030     if ( cls == NULL)
1031     {
1032         throw GiwsException::JniCallMethodException(curEnv);
1033     }
1034
1035     jmethodID jintwrapjobjectArray__doubledoubleID = curEnv->GetStaticMethodID(cls, "wrap", "([[D)I" ) ;
1036     if (jintwrapjobjectArray__doubledoubleID == NULL)
1037     {
1038         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1039     }
1040
1041     jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[D"), NULL);
1042
1043     if (x_ == NULL)
1044     {
1045         // check that allocation succeed
1046         throw GiwsException::JniBadAllocException(curEnv);
1047     }
1048
1049     for (int i = 0; i < xSize; i++)
1050     {
1051
1052         jdoubleArray xLocal = curEnv->NewDoubleArray( xSizeCol ) ;
1053
1054         if (xLocal == NULL)
1055         {
1056             // check that allocation succeed
1057             curEnv->DeleteLocalRef(x_);
1058             throw GiwsException::JniBadAllocException(curEnv);
1059         }
1060
1061         curEnv->SetDoubleArrayRegion( xLocal, 0, xSizeCol, (jdouble*)(x[i]) ) ;
1062         curEnv->SetObjectArrayElement(x_, i, xLocal);
1063         curEnv->DeleteLocalRef(xLocal);
1064     }
1065
1066     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__doubledoubleID , x_));
1067     curEnv->DeleteLocalRef(x_);
1068     curEnv->DeleteLocalRef(cls);
1069     if (curEnv->ExceptionCheck())
1070     {
1071         throw GiwsException::JniCallMethodException(curEnv);
1072     }
1073     return res;
1074
1075 }
1076
1077 int ScilabJavaObject::wrap (JavaVM * jvm_, int x)
1078 {
1079
1080     JNIEnv * curEnv = NULL;
1081     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1082     jclass cls = curEnv->FindClass( className().c_str() );
1083     if ( cls == NULL)
1084     {
1085         throw GiwsException::JniCallMethodException(curEnv);
1086     }
1087
1088     jmethodID jintwrapjintintID = curEnv->GetStaticMethodID(cls, "wrap", "(I)I" ) ;
1089     if (jintwrapjintintID == NULL)
1090     {
1091         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1092     }
1093
1094     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjintintID , x));
1095     curEnv->DeleteLocalRef(cls);
1096     if (curEnv->ExceptionCheck())
1097     {
1098         throw GiwsException::JniCallMethodException(curEnv);
1099     }
1100     return res;
1101
1102 }
1103
1104 int ScilabJavaObject::wrap (JavaVM * jvm_, int const* x, int xSize)
1105 {
1106
1107     JNIEnv * curEnv = NULL;
1108     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1109     jclass cls = curEnv->FindClass( className().c_str() );
1110     if ( cls == NULL)
1111     {
1112         throw GiwsException::JniCallMethodException(curEnv);
1113     }
1114
1115     jmethodID jintwrapjintArray_intintID = curEnv->GetStaticMethodID(cls, "wrap", "([I)I" ) ;
1116     if (jintwrapjintArray_intintID == NULL)
1117     {
1118         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1119     }
1120
1121     jintArray x_ = curEnv->NewIntArray( xSize ) ;
1122
1123     if (x_ == NULL)
1124     {
1125         // check that allocation succeed
1126         throw GiwsException::JniBadAllocException(curEnv);
1127     }
1128
1129     curEnv->SetIntArrayRegion( x_, 0, xSize, (jint*)(x) ) ;
1130
1131
1132     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjintArray_intintID , x_));
1133     curEnv->DeleteLocalRef(x_);
1134     curEnv->DeleteLocalRef(cls);
1135     if (curEnv->ExceptionCheck())
1136     {
1137         throw GiwsException::JniCallMethodException(curEnv);
1138     }
1139     return res;
1140
1141 }
1142
1143 int ScilabJavaObject::wrap (JavaVM * jvm_, int const* const* x, int xSize, int xSizeCol)
1144 {
1145
1146     JNIEnv * curEnv = NULL;
1147     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1148     jclass cls = curEnv->FindClass( className().c_str() );
1149     if ( cls == NULL)
1150     {
1151         throw GiwsException::JniCallMethodException(curEnv);
1152     }
1153
1154     jmethodID jintwrapjobjectArray__intintID = curEnv->GetStaticMethodID(cls, "wrap", "([[I)I" ) ;
1155     if (jintwrapjobjectArray__intintID == NULL)
1156     {
1157         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1158     }
1159
1160     jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[I"), NULL);
1161
1162     if (x_ == NULL)
1163     {
1164         // check that allocation succeed
1165         throw GiwsException::JniBadAllocException(curEnv);
1166     }
1167
1168     for (int i = 0; i < xSize; i++)
1169     {
1170
1171         jintArray xLocal = curEnv->NewIntArray( xSizeCol ) ;
1172
1173         if (xLocal == NULL)
1174         {
1175             // check that allocation succeed
1176             curEnv->DeleteLocalRef(x_);
1177             throw GiwsException::JniBadAllocException(curEnv);
1178         }
1179
1180         curEnv->SetIntArrayRegion( xLocal, 0, xSizeCol, (jint*)(x[i]) ) ;
1181         curEnv->SetObjectArrayElement(x_, i, xLocal);
1182         curEnv->DeleteLocalRef(xLocal);
1183     }
1184
1185     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__intintID , x_));
1186     curEnv->DeleteLocalRef(x_);
1187     curEnv->DeleteLocalRef(cls);
1188     if (curEnv->ExceptionCheck())
1189     {
1190         throw GiwsException::JniCallMethodException(curEnv);
1191     }
1192     return res;
1193
1194 }
1195
1196 int ScilabJavaObject::wrap (JavaVM * jvm_, byte x)
1197 {
1198
1199     JNIEnv * curEnv = NULL;
1200     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1201     jclass cls = curEnv->FindClass( className().c_str() );
1202     if ( cls == NULL)
1203     {
1204         throw GiwsException::JniCallMethodException(curEnv);
1205     }
1206
1207     jmethodID jintwrapjbytebyteID = curEnv->GetStaticMethodID(cls, "wrap", "(B)I" ) ;
1208     if (jintwrapjbytebyteID == NULL)
1209     {
1210         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1211     }
1212
1213     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbytebyteID , x));
1214     curEnv->DeleteLocalRef(cls);
1215     if (curEnv->ExceptionCheck())
1216     {
1217         throw GiwsException::JniCallMethodException(curEnv);
1218     }
1219     return res;
1220
1221 }
1222
1223 int ScilabJavaObject::wrap (JavaVM * jvm_, byte const* x, int xSize)
1224 {
1225
1226     JNIEnv * curEnv = NULL;
1227     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1228     jclass cls = curEnv->FindClass( className().c_str() );
1229     if ( cls == NULL)
1230     {
1231         throw GiwsException::JniCallMethodException(curEnv);
1232     }
1233
1234     jmethodID jintwrapjbyteArray_bytebyteID = curEnv->GetStaticMethodID(cls, "wrap", "([B)I" ) ;
1235     if (jintwrapjbyteArray_bytebyteID == NULL)
1236     {
1237         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1238     }
1239
1240     jbyteArray x_ = curEnv->NewByteArray( xSize ) ;
1241
1242     if (x_ == NULL)
1243     {
1244         // check that allocation succeed
1245         throw GiwsException::JniBadAllocException(curEnv);
1246     }
1247
1248     curEnv->SetByteArrayRegion( x_, 0, xSize, (jbyte*)(x) ) ;
1249
1250
1251     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbyteArray_bytebyteID , x_));
1252     curEnv->DeleteLocalRef(x_);
1253     curEnv->DeleteLocalRef(cls);
1254     if (curEnv->ExceptionCheck())
1255     {
1256         throw GiwsException::JniCallMethodException(curEnv);
1257     }
1258     return res;
1259
1260 }
1261
1262 int ScilabJavaObject::wrap (JavaVM * jvm_, byte const* const* x, int xSize, int xSizeCol)
1263 {
1264
1265     JNIEnv * curEnv = NULL;
1266     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1267     jclass cls = curEnv->FindClass( className().c_str() );
1268     if ( cls == NULL)
1269     {
1270         throw GiwsException::JniCallMethodException(curEnv);
1271     }
1272
1273     jmethodID jintwrapjobjectArray__bytebyteID = curEnv->GetStaticMethodID(cls, "wrap", "([[B)I" ) ;
1274     if (jintwrapjobjectArray__bytebyteID == NULL)
1275     {
1276         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1277     }
1278
1279     jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[B"), NULL);
1280
1281     if (x_ == NULL)
1282     {
1283         // check that allocation succeed
1284         throw GiwsException::JniBadAllocException(curEnv);
1285     }
1286
1287     for (int i = 0; i < xSize; i++)
1288     {
1289
1290         jbyteArray xLocal = curEnv->NewByteArray( xSizeCol ) ;
1291
1292         if (xLocal == NULL)
1293         {
1294             // check that allocation succeed
1295             curEnv->DeleteLocalRef(x_);
1296             throw GiwsException::JniBadAllocException(curEnv);
1297         }
1298
1299         curEnv->SetByteArrayRegion( xLocal, 0, xSizeCol, (jbyte*)(x[i]) ) ;
1300         curEnv->SetObjectArrayElement(x_, i, xLocal);
1301         curEnv->DeleteLocalRef(xLocal);
1302     }
1303
1304     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__bytebyteID , x_));
1305     curEnv->DeleteLocalRef(x_);
1306     curEnv->DeleteLocalRef(cls);
1307     if (curEnv->ExceptionCheck())
1308     {
1309         throw GiwsException::JniCallMethodException(curEnv);
1310     }
1311     return res;
1312
1313 }
1314
1315 int ScilabJavaObject::wrap (JavaVM * jvm_, short x)
1316 {
1317
1318     JNIEnv * curEnv = NULL;
1319     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1320     jclass cls = curEnv->FindClass( className().c_str() );
1321     if ( cls == NULL)
1322     {
1323         throw GiwsException::JniCallMethodException(curEnv);
1324     }
1325
1326     jmethodID jintwrapjshortshortID = curEnv->GetStaticMethodID(cls, "wrap", "(S)I" ) ;
1327     if (jintwrapjshortshortID == NULL)
1328     {
1329         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1330     }
1331
1332     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjshortshortID , x));
1333     curEnv->DeleteLocalRef(cls);
1334     if (curEnv->ExceptionCheck())
1335     {
1336         throw GiwsException::JniCallMethodException(curEnv);
1337     }
1338     return res;
1339
1340 }
1341
1342 int ScilabJavaObject::wrap (JavaVM * jvm_, short const* x, int xSize)
1343 {
1344
1345     JNIEnv * curEnv = NULL;
1346     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1347     jclass cls = curEnv->FindClass( className().c_str() );
1348     if ( cls == NULL)
1349     {
1350         throw GiwsException::JniCallMethodException(curEnv);
1351     }
1352
1353     jmethodID jintwrapjshortArray_shortshortID = curEnv->GetStaticMethodID(cls, "wrap", "([S)I" ) ;
1354     if (jintwrapjshortArray_shortshortID == NULL)
1355     {
1356         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1357     }
1358
1359     jshortArray x_ = curEnv->NewShortArray( xSize ) ;
1360
1361     if (x_ == NULL)
1362     {
1363         // check that allocation succeed
1364         throw GiwsException::JniBadAllocException(curEnv);
1365     }
1366
1367     curEnv->SetShortArrayRegion( x_, 0, xSize, (jshort*)(x) ) ;
1368
1369
1370     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjshortArray_shortshortID , x_));
1371     curEnv->DeleteLocalRef(x_);
1372     curEnv->DeleteLocalRef(cls);
1373     if (curEnv->ExceptionCheck())
1374     {
1375         throw GiwsException::JniCallMethodException(curEnv);
1376     }
1377     return res;
1378
1379 }
1380
1381 int ScilabJavaObject::wrap (JavaVM * jvm_, short const* const* x, int xSize, int xSizeCol)
1382 {
1383
1384     JNIEnv * curEnv = NULL;
1385     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1386     jclass cls = curEnv->FindClass( className().c_str() );
1387     if ( cls == NULL)
1388     {
1389         throw GiwsException::JniCallMethodException(curEnv);
1390     }
1391
1392     jmethodID jintwrapjobjectArray__shortshortID = curEnv->GetStaticMethodID(cls, "wrap", "([[S)I" ) ;
1393     if (jintwrapjobjectArray__shortshortID == NULL)
1394     {
1395         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1396     }
1397
1398     jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[S"), NULL);
1399
1400     if (x_ == NULL)
1401     {
1402         // check that allocation succeed
1403         throw GiwsException::JniBadAllocException(curEnv);
1404     }
1405
1406     for (int i = 0; i < xSize; i++)
1407     {
1408
1409         jshortArray xLocal = curEnv->NewShortArray( xSizeCol ) ;
1410
1411         if (xLocal == NULL)
1412         {
1413             // check that allocation succeed
1414             curEnv->DeleteLocalRef(x_);
1415             throw GiwsException::JniBadAllocException(curEnv);
1416         }
1417
1418         curEnv->SetShortArrayRegion( xLocal, 0, xSizeCol, (jshort*)(x[i]) ) ;
1419         curEnv->SetObjectArrayElement(x_, i, xLocal);
1420         curEnv->DeleteLocalRef(xLocal);
1421     }
1422
1423     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__shortshortID , x_));
1424     curEnv->DeleteLocalRef(x_);
1425     curEnv->DeleteLocalRef(cls);
1426     if (curEnv->ExceptionCheck())
1427     {
1428         throw GiwsException::JniCallMethodException(curEnv);
1429     }
1430     return res;
1431
1432 }
1433
1434 int ScilabJavaObject::wrap (JavaVM * jvm_, char const* x)
1435 {
1436
1437     JNIEnv * curEnv = NULL;
1438     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1439     jclass cls = curEnv->FindClass( className().c_str() );
1440     if ( cls == NULL)
1441     {
1442         throw GiwsException::JniCallMethodException(curEnv);
1443     }
1444
1445     jmethodID jintwrapjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "wrap", "(Ljava/lang/String;)I" ) ;
1446     if (jintwrapjstringjava_lang_StringID == NULL)
1447     {
1448         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1449     }
1450
1451     jstring x_ = curEnv->NewStringUTF( x );
1452     if (x != NULL && x_ == NULL)
1453     {
1454         throw GiwsException::JniBadAllocException(curEnv);
1455     }
1456
1457
1458     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjstringjava_lang_StringID , x_));
1459     curEnv->DeleteLocalRef(x_);
1460     curEnv->DeleteLocalRef(cls);
1461     if (curEnv->ExceptionCheck())
1462     {
1463         throw GiwsException::JniCallMethodException(curEnv);
1464     }
1465     return res;
1466
1467 }
1468
1469 int ScilabJavaObject::wrap (JavaVM * jvm_, char const* const* x, int xSize)
1470 {
1471
1472     JNIEnv * curEnv = NULL;
1473     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1474     jclass cls = curEnv->FindClass( className().c_str() );
1475     if ( cls == NULL)
1476     {
1477         throw GiwsException::JniCallMethodException(curEnv);
1478     }
1479
1480     jmethodID jintwrapjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "wrap", "([Ljava/lang/String;)I" ) ;
1481     if (jintwrapjobjectArray_java_lang_Stringjava_lang_StringID == NULL)
1482     {
1483         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1484     }
1485     jclass stringArrayClass = curEnv->FindClass("java/lang/String");
1486
1487     // create java array of strings.
1488     jobjectArray x_ = curEnv->NewObjectArray( xSize, stringArrayClass, NULL);
1489     if (x_ == NULL)
1490     {
1491         throw GiwsException::JniBadAllocException(curEnv);
1492     }
1493
1494     // convert each char * to java strings and fill the java array.
1495     for ( int i = 0; i < xSize; i++)
1496     {
1497         jstring TempString = curEnv->NewStringUTF( x[i] );
1498         if (TempString == NULL)
1499         {
1500             throw GiwsException::JniBadAllocException(curEnv);
1501         }
1502
1503         curEnv->SetObjectArrayElement( x_, i, TempString);
1504
1505         // avoid keeping reference on too many strings
1506         curEnv->DeleteLocalRef(TempString);
1507     }
1508     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray_java_lang_Stringjava_lang_StringID , x_));
1509     curEnv->DeleteLocalRef(stringArrayClass);
1510     curEnv->DeleteLocalRef(x_);
1511     curEnv->DeleteLocalRef(cls);
1512     if (curEnv->ExceptionCheck())
1513     {
1514         throw GiwsException::JniCallMethodException(curEnv);
1515     }
1516     return res;
1517
1518 }
1519
1520 int ScilabJavaObject::wrap (JavaVM * jvm_, char const* const* const* x, int xSize, int xSizeCol)
1521 {
1522
1523     JNIEnv * curEnv = NULL;
1524     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1525     jclass cls = curEnv->FindClass( className().c_str() );
1526     if ( cls == NULL)
1527     {
1528         throw GiwsException::JniCallMethodException(curEnv);
1529     }
1530
1531     jmethodID jintwrapjobjectArray__java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "wrap", "([[Ljava/lang/String;)I" ) ;
1532     if (jintwrapjobjectArray__java_lang_Stringjava_lang_StringID == NULL)
1533     {
1534         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1535     }
1536     jclass stringArrayClass = curEnv->FindClass("java/lang/String");
1537     // create java array of array of strings.
1538     jobjectArray x_ = curEnv->NewObjectArray( xSize, curEnv->FindClass("[Ljava/lang/String;"), NULL);
1539     if (x_ == NULL)
1540     {
1541         throw GiwsException::JniBadAllocException(curEnv);
1542     }
1543
1544     for ( int i = 0; i < xSize; i++)
1545     {
1546         jobjectArray xLocal = curEnv->NewObjectArray( xSizeCol, stringArrayClass, NULL);
1547         // convert each char * to java strings and fill the java array.
1548         for ( int j = 0; j < xSizeCol; j++)
1549         {
1550             jstring TempString = curEnv->NewStringUTF( x[i][j] );
1551
1552             if (TempString == NULL)
1553             {
1554                 throw GiwsException::JniBadAllocException(curEnv);
1555             }
1556
1557             curEnv->SetObjectArrayElement( xLocal, j, TempString);
1558
1559             // avoid keeping reference on too many strings
1560             curEnv->DeleteLocalRef(TempString);
1561         }
1562         curEnv->SetObjectArrayElement(x_, i, xLocal);
1563         curEnv->DeleteLocalRef(xLocal);
1564
1565     }
1566     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__java_lang_Stringjava_lang_StringID , x_));
1567     curEnv->DeleteLocalRef(stringArrayClass);
1568     curEnv->DeleteLocalRef(x_);
1569     curEnv->DeleteLocalRef(cls);
1570     if (curEnv->ExceptionCheck())
1571     {
1572         throw GiwsException::JniCallMethodException(curEnv);
1573     }
1574     return res;
1575
1576 }
1577
1578 int ScilabJavaObject::wrap (JavaVM * jvm_, bool x)
1579 {
1580
1581     JNIEnv * curEnv = NULL;
1582     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1583     jclass cls = curEnv->FindClass( className().c_str() );
1584     if ( cls == NULL)
1585     {
1586         throw GiwsException::JniCallMethodException(curEnv);
1587     }
1588
1589     jmethodID jintwrapjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "wrap", "(Z)I" ) ;
1590     if (jintwrapjbooleanbooleanID == NULL)
1591     {
1592         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1593     }
1594
1595     jboolean x_ = (static_cast<bool>(x) ? JNI_TRUE : JNI_FALSE);
1596
1597     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbooleanbooleanID , x_));
1598     curEnv->DeleteLocalRef(cls);
1599     if (curEnv->ExceptionCheck())
1600     {
1601         throw GiwsException::JniCallMethodException(curEnv);
1602     }
1603     return res;
1604
1605 }
1606
1607 int ScilabJavaObject::wrap (JavaVM * jvm_, bool const* x, int xSize)
1608 {
1609
1610     JNIEnv * curEnv = NULL;
1611     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1612     jclass cls = curEnv->FindClass( className().c_str() );
1613     if ( cls == NULL)
1614     {
1615         throw GiwsException::JniCallMethodException(curEnv);
1616     }
1617
1618     jmethodID jintwrapjbooleanArray_booleanbooleanID = curEnv->GetStaticMethodID(cls, "wrap", "([Z)I" ) ;
1619     if (jintwrapjbooleanArray_booleanbooleanID == NULL)
1620     {
1621         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1622     }
1623
1624     jbooleanArray x_ = curEnv->NewBooleanArray( xSize ) ;
1625     curEnv->SetBooleanArrayRegion( x_, 0, xSize, (jboolean*)x ) ;
1626
1627     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbooleanArray_booleanbooleanID , x_));
1628     curEnv->DeleteLocalRef(x_);
1629     curEnv->DeleteLocalRef(cls);
1630     if (curEnv->ExceptionCheck())
1631     {
1632         throw GiwsException::JniCallMethodException(curEnv);
1633     }
1634     return res;
1635
1636 }
1637
1638 int ScilabJavaObject::wrap (JavaVM * jvm_, bool const* const* x, int xSize, int xSizeCol)
1639 {
1640
1641     JNIEnv * curEnv = NULL;
1642     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1643     jclass cls = curEnv->FindClass( className().c_str() );
1644     if ( cls == NULL)
1645     {
1646         throw GiwsException::JniCallMethodException(curEnv);
1647     }
1648
1649     jmethodID jintwrapjobjectArray__booleanbooleanID = curEnv->GetStaticMethodID(cls, "wrap", "([[Z)I" ) ;
1650     if (jintwrapjobjectArray__booleanbooleanID == NULL)
1651     {
1652         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1653     }
1654
1655     jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[Z"), NULL);
1656     for (int i = 0; i < xSize; i++)
1657     {
1658         jbooleanArray xLocal = curEnv->NewBooleanArray( xSizeCol ) ;
1659         curEnv->SetBooleanArrayRegion( xLocal, 0, xSizeCol, (jboolean*)(x[i]) ) ;
1660         curEnv->SetObjectArrayElement(x_, i, xLocal);
1661         curEnv->DeleteLocalRef(xLocal);
1662     }
1663
1664     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__booleanbooleanID , x_));
1665     curEnv->DeleteLocalRef(x_);
1666     curEnv->DeleteLocalRef(cls);
1667     if (curEnv->ExceptionCheck())
1668     {
1669         throw GiwsException::JniCallMethodException(curEnv);
1670     }
1671     return res;
1672
1673 }
1674
1675 int ScilabJavaObject::wrap (JavaVM * jvm_, unsigned short x)
1676 {
1677
1678     JNIEnv * curEnv = NULL;
1679     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1680     jclass cls = curEnv->FindClass( className().c_str() );
1681     if ( cls == NULL)
1682     {
1683         throw GiwsException::JniCallMethodException(curEnv);
1684     }
1685
1686     jmethodID jintwrapjcharcharID = curEnv->GetStaticMethodID(cls, "wrap", "(C)I" ) ;
1687     if (jintwrapjcharcharID == NULL)
1688     {
1689         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1690     }
1691
1692     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjcharcharID , x));
1693     curEnv->DeleteLocalRef(cls);
1694     if (curEnv->ExceptionCheck())
1695     {
1696         throw GiwsException::JniCallMethodException(curEnv);
1697     }
1698     return res;
1699
1700 }
1701
1702 int ScilabJavaObject::wrap (JavaVM * jvm_, unsigned short const* x, int xSize)
1703 {
1704
1705     JNIEnv * curEnv = NULL;
1706     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1707     jclass cls = curEnv->FindClass( className().c_str() );
1708     if ( cls == NULL)
1709     {
1710         throw GiwsException::JniCallMethodException(curEnv);
1711     }
1712
1713     jmethodID jintwrapjcharArray_charcharID = curEnv->GetStaticMethodID(cls, "wrap", "([C)I" ) ;
1714     if (jintwrapjcharArray_charcharID == NULL)
1715     {
1716         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1717     }
1718
1719     jcharArray x_ = curEnv->NewCharArray( xSize ) ;
1720
1721     if (x_ == NULL)
1722     {
1723         // check that allocation succeed
1724         throw GiwsException::JniBadAllocException(curEnv);
1725     }
1726
1727     curEnv->SetCharArrayRegion( x_, 0, xSize, (jchar*)(x) ) ;
1728
1729
1730     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjcharArray_charcharID , x_));
1731     curEnv->DeleteLocalRef(x_);
1732     curEnv->DeleteLocalRef(cls);
1733     if (curEnv->ExceptionCheck())
1734     {
1735         throw GiwsException::JniCallMethodException(curEnv);
1736     }
1737     return res;
1738
1739 }
1740
1741 int ScilabJavaObject::wrap (JavaVM * jvm_, unsigned short const* const* x, int xSize, int xSizeCol)
1742 {
1743
1744     JNIEnv * curEnv = NULL;
1745     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1746     jclass cls = curEnv->FindClass( className().c_str() );
1747     if ( cls == NULL)
1748     {
1749         throw GiwsException::JniCallMethodException(curEnv);
1750     }
1751
1752     jmethodID jintwrapjobjectArray__charcharID = curEnv->GetStaticMethodID(cls, "wrap", "([[C)I" ) ;
1753     if (jintwrapjobjectArray__charcharID == NULL)
1754     {
1755         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1756     }
1757
1758     jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[C"), NULL);
1759
1760     if (x_ == NULL)
1761     {
1762         // check that allocation succeed
1763         throw GiwsException::JniBadAllocException(curEnv);
1764     }
1765
1766     for (int i = 0; i < xSize; i++)
1767     {
1768
1769         jcharArray xLocal = curEnv->NewCharArray( xSizeCol ) ;
1770
1771         if (xLocal == NULL)
1772         {
1773             // check that allocation succeed
1774             curEnv->DeleteLocalRef(x_);
1775             throw GiwsException::JniBadAllocException(curEnv);
1776         }
1777
1778         curEnv->SetCharArrayRegion( xLocal, 0, xSizeCol, (jchar*)(x[i]) ) ;
1779         curEnv->SetObjectArrayElement(x_, i, xLocal);
1780         curEnv->DeleteLocalRef(xLocal);
1781     }
1782
1783     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__charcharID , x_));
1784     curEnv->DeleteLocalRef(x_);
1785     curEnv->DeleteLocalRef(cls);
1786     if (curEnv->ExceptionCheck())
1787     {
1788         throw GiwsException::JniCallMethodException(curEnv);
1789     }
1790     return res;
1791
1792 }
1793
1794 int ScilabJavaObject::wrap (JavaVM * jvm_, float x)
1795 {
1796
1797     JNIEnv * curEnv = NULL;
1798     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1799     jclass cls = curEnv->FindClass( className().c_str() );
1800     if ( cls == NULL)
1801     {
1802         throw GiwsException::JniCallMethodException(curEnv);
1803     }
1804
1805     jmethodID jintwrapjfloatfloatID = curEnv->GetStaticMethodID(cls, "wrap", "(F)I" ) ;
1806     if (jintwrapjfloatfloatID == NULL)
1807     {
1808         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1809     }
1810
1811     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjfloatfloatID , x));
1812     curEnv->DeleteLocalRef(cls);
1813     if (curEnv->ExceptionCheck())
1814     {
1815         throw GiwsException::JniCallMethodException(curEnv);
1816     }
1817     return res;
1818
1819 }
1820
1821 int ScilabJavaObject::wrap (JavaVM * jvm_, float const* x, int xSize)
1822 {
1823
1824     JNIEnv * curEnv = NULL;
1825     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1826     jclass cls = curEnv->FindClass( className().c_str() );
1827     if ( cls == NULL)
1828     {
1829         throw GiwsException::JniCallMethodException(curEnv);
1830     }
1831
1832     jmethodID jintwrapjfloatArray_floatfloatID = curEnv->GetStaticMethodID(cls, "wrap", "([F)I" ) ;
1833     if (jintwrapjfloatArray_floatfloatID == NULL)
1834     {
1835         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1836     }
1837
1838     jfloatArray x_ = curEnv->NewFloatArray( xSize ) ;
1839
1840     if (x_ == NULL)
1841     {
1842         // check that allocation succeed
1843         throw GiwsException::JniBadAllocException(curEnv);
1844     }
1845
1846     curEnv->SetFloatArrayRegion( x_, 0, xSize, (jfloat*)(x) ) ;
1847
1848
1849     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjfloatArray_floatfloatID , x_));
1850     curEnv->DeleteLocalRef(x_);
1851     curEnv->DeleteLocalRef(cls);
1852     if (curEnv->ExceptionCheck())
1853     {
1854         throw GiwsException::JniCallMethodException(curEnv);
1855     }
1856     return res;
1857
1858 }
1859
1860 int ScilabJavaObject::wrap (JavaVM * jvm_, float const* const* x, int xSize, int xSizeCol)
1861 {
1862
1863     JNIEnv * curEnv = NULL;
1864     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1865     jclass cls = curEnv->FindClass( className().c_str() );
1866     if ( cls == NULL)
1867     {
1868         throw GiwsException::JniCallMethodException(curEnv);
1869     }
1870
1871     jmethodID jintwrapjobjectArray__floatfloatID = curEnv->GetStaticMethodID(cls, "wrap", "([[F)I" ) ;
1872     if (jintwrapjobjectArray__floatfloatID == NULL)
1873     {
1874         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1875     }
1876
1877     jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[F"), NULL);
1878
1879     if (x_ == NULL)
1880     {
1881         // check that allocation succeed
1882         throw GiwsException::JniBadAllocException(curEnv);
1883     }
1884
1885     for (int i = 0; i < xSize; i++)
1886     {
1887
1888         jfloatArray xLocal = curEnv->NewFloatArray( xSizeCol ) ;
1889
1890         if (xLocal == NULL)
1891         {
1892             // check that allocation succeed
1893             curEnv->DeleteLocalRef(x_);
1894             throw GiwsException::JniBadAllocException(curEnv);
1895         }
1896
1897         curEnv->SetFloatArrayRegion( xLocal, 0, xSizeCol, (jfloat*)(x[i]) ) ;
1898         curEnv->SetObjectArrayElement(x_, i, xLocal);
1899         curEnv->DeleteLocalRef(xLocal);
1900     }
1901
1902     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__floatfloatID , x_));
1903     curEnv->DeleteLocalRef(x_);
1904     curEnv->DeleteLocalRef(cls);
1905     if (curEnv->ExceptionCheck())
1906     {
1907         throw GiwsException::JniCallMethodException(curEnv);
1908     }
1909     return res;
1910
1911 }
1912
1913 int ScilabJavaObject::wrap (JavaVM * jvm_, long long x)
1914 {
1915
1916     JNIEnv * curEnv = NULL;
1917     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1918     jclass cls = curEnv->FindClass( className().c_str() );
1919     if ( cls == NULL)
1920     {
1921         throw GiwsException::JniCallMethodException(curEnv);
1922     }
1923
1924     jmethodID jintwrapjlonglongID = curEnv->GetStaticMethodID(cls, "wrap", "(J)I" ) ;
1925     if (jintwrapjlonglongID == NULL)
1926     {
1927         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1928     }
1929
1930     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjlonglongID , x));
1931     curEnv->DeleteLocalRef(cls);
1932     if (curEnv->ExceptionCheck())
1933     {
1934         throw GiwsException::JniCallMethodException(curEnv);
1935     }
1936     return res;
1937
1938 }
1939
1940 int ScilabJavaObject::wrap (JavaVM * jvm_, long long const* x, int xSize)
1941 {
1942
1943     JNIEnv * curEnv = NULL;
1944     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1945     jclass cls = curEnv->FindClass( className().c_str() );
1946     if ( cls == NULL)
1947     {
1948         throw GiwsException::JniCallMethodException(curEnv);
1949     }
1950
1951     jmethodID jintwrapjlongArray_longlongID = curEnv->GetStaticMethodID(cls, "wrap", "([J)I" ) ;
1952     if (jintwrapjlongArray_longlongID == NULL)
1953     {
1954         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1955     }
1956
1957     jlongArray x_ = curEnv->NewLongArray( xSize ) ;
1958
1959     if (x_ == NULL)
1960     {
1961         // check that allocation succeed
1962         throw GiwsException::JniBadAllocException(curEnv);
1963     }
1964
1965     curEnv->SetLongArrayRegion( x_, 0, xSize, (jlong*)(x) ) ;
1966
1967
1968     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjlongArray_longlongID , x_));
1969     curEnv->DeleteLocalRef(x_);
1970     curEnv->DeleteLocalRef(cls);
1971     if (curEnv->ExceptionCheck())
1972     {
1973         throw GiwsException::JniCallMethodException(curEnv);
1974     }
1975     return res;
1976
1977 }
1978
1979 int ScilabJavaObject::wrap (JavaVM * jvm_, long long const* const* x, int xSize, int xSizeCol)
1980 {
1981
1982     JNIEnv * curEnv = NULL;
1983     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1984     jclass cls = curEnv->FindClass( className().c_str() );
1985     if ( cls == NULL)
1986     {
1987         throw GiwsException::JniCallMethodException(curEnv);
1988     }
1989
1990     jmethodID jintwrapjobjectArray__longlongID = curEnv->GetStaticMethodID(cls, "wrap", "([[J)I" ) ;
1991     if (jintwrapjobjectArray__longlongID == NULL)
1992     {
1993         throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1994     }
1995
1996     jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[J"), NULL);
1997
1998     if (x_ == NULL)
1999     {
2000         // check that allocation succeed
2001         throw GiwsException::JniBadAllocException(curEnv);
2002     }
2003
2004     for (int i = 0; i < xSize; i++)
2005     {
2006
2007         jlongArray xLocal = curEnv->NewLongArray( xSizeCol ) ;
2008
2009         if (xLocal == NULL)
2010         {
2011             // check that allocation succeed
2012             curEnv->DeleteLocalRef(x_);
2013             throw GiwsException::JniBadAllocException(curEnv);
2014         }
2015
2016         curEnv->SetLongArrayRegion( xLocal, 0, xSizeCol, (jlong*)(x[i]) ) ;
2017         curEnv->SetObjectArrayElement(x_, i, xLocal);
2018         curEnv->DeleteLocalRef(xLocal);
2019     }
2020
2021     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__longlongID , x_));
2022     curEnv->DeleteLocalRef(x_);
2023     curEnv->DeleteLocalRef(cls);
2024     if (curEnv->ExceptionCheck())
2025     {
2026         throw GiwsException::JniCallMethodException(curEnv);
2027     }
2028     return res;
2029
2030 }
2031
2032 double ScilabJavaObject::unwrapDouble (JavaVM * jvm_, int x)
2033 {
2034
2035     JNIEnv * curEnv = NULL;
2036     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2037     jclass cls = curEnv->FindClass( className().c_str() );
2038     if ( cls == NULL)
2039     {
2040         throw GiwsException::JniCallMethodException(curEnv);
2041     }
2042
2043     jmethodID jdoubleunwrapDoublejintintID = curEnv->GetStaticMethodID(cls, "unwrapDouble", "(I)D" ) ;
2044     if (jdoubleunwrapDoublejintintID == NULL)
2045     {
2046         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapDouble");
2047     }
2048
2049     jdouble res =  static_cast<jdouble>( curEnv->CallStaticDoubleMethod(cls, jdoubleunwrapDoublejintintID , x));
2050     curEnv->DeleteLocalRef(cls);
2051     if (curEnv->ExceptionCheck())
2052     {
2053         throw GiwsException::JniCallMethodException(curEnv);
2054     }
2055     return res;
2056
2057 }
2058
2059 double* ScilabJavaObject::unwrapRowDouble (JavaVM * jvm_, int x)
2060 {
2061
2062     JNIEnv * curEnv = NULL;
2063     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2064     jclass cls = curEnv->FindClass( className().c_str() );
2065     if ( cls == NULL)
2066     {
2067         throw GiwsException::JniCallMethodException(curEnv);
2068     }
2069
2070     jmethodID jdoubleArray_unwrapRowDoublejintintID = curEnv->GetStaticMethodID(cls, "unwrapRowDouble", "(I)[D" ) ;
2071     if (jdoubleArray_unwrapRowDoublejintintID == NULL)
2072     {
2073         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapRowDouble");
2074     }
2075
2076     jdoubleArray res =  static_cast<jdoubleArray>( curEnv->CallStaticObjectMethod(cls, jdoubleArray_unwrapRowDoublejintintID , x));
2077     if (res == NULL)
2078     {
2079         return NULL;
2080     }
2081     if (curEnv->ExceptionCheck())
2082     {
2083         throw GiwsException::JniCallMethodException(curEnv);
2084     }
2085     int lenRow;
2086     lenRow = curEnv->GetArrayLength(res);
2087     jboolean isCopy = JNI_FALSE;
2088
2089     /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
2090     jdouble *resultsArray = static_cast<jdouble *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
2091     double* myArray = new double[ lenRow];
2092
2093     for (jsize i = 0; i <  lenRow; i++)
2094     {
2095         myArray[i] = resultsArray[i];
2096     }
2097     curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
2098
2099     curEnv->DeleteLocalRef(res);
2100     curEnv->DeleteLocalRef(cls);
2101     if (curEnv->ExceptionCheck())
2102     {
2103         delete[] myArray;
2104         throw GiwsException::JniCallMethodException(curEnv);
2105     }
2106     return myArray;
2107
2108 }
2109
2110 double** ScilabJavaObject::unwrapMatDouble (JavaVM * jvm_, int x)
2111 {
2112
2113     JNIEnv * curEnv = NULL;
2114     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2115     jclass cls = curEnv->FindClass( className().c_str() );
2116     if ( cls == NULL)
2117     {
2118         throw GiwsException::JniCallMethodException(curEnv);
2119     }
2120
2121     jmethodID jobjectArray__unwrapMatDoublejintintID = curEnv->GetStaticMethodID(cls, "unwrapMatDouble", "(I)[[D" ) ;
2122     if (jobjectArray__unwrapMatDoublejintintID == NULL)
2123     {
2124         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapMatDouble");
2125     }
2126
2127     jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray__unwrapMatDoublejintintID , x));
2128     if (res == NULL)
2129     {
2130         return NULL;
2131     }
2132     if (curEnv->ExceptionCheck())
2133     {
2134         throw GiwsException::JniCallMethodException(curEnv);
2135     }
2136     int lenCol;
2137     int lenRow;
2138     lenRow = curEnv->GetArrayLength(res);
2139     jboolean isCopy = JNI_FALSE;
2140
2141     double ** myArray = new double*[ lenRow];
2142     for (int i = 0; i < lenRow; i++)
2143     {
2144         jdoubleArray oneDim = (jdoubleArray)curEnv->GetObjectArrayElement(res, i);
2145         lenCol = curEnv->GetArrayLength(oneDim);
2146         double *resultsArray = static_cast<double *>(curEnv->GetPrimitiveArrayCritical(oneDim, &isCopy));
2147         myArray[i] = new double[ lenCol];
2148         for (int j = 0; j < lenCol; j++)
2149         {
2150             myArray[i][j] = resultsArray[j];
2151         }
2152         curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
2153     }
2154
2155     curEnv->DeleteLocalRef(res);
2156     curEnv->DeleteLocalRef(cls);
2157     if (curEnv->ExceptionCheck())
2158     {
2159         delete[] myArray;
2160         throw GiwsException::JniCallMethodException(curEnv);
2161     }
2162     return myArray;
2163
2164 }
2165
2166 int ScilabJavaObject::unwrapInt (JavaVM * jvm_, int x)
2167 {
2168
2169     JNIEnv * curEnv = NULL;
2170     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2171     jclass cls = curEnv->FindClass( className().c_str() );
2172     if ( cls == NULL)
2173     {
2174         throw GiwsException::JniCallMethodException(curEnv);
2175     }
2176
2177     jmethodID jintunwrapIntjintintID = curEnv->GetStaticMethodID(cls, "unwrapInt", "(I)I" ) ;
2178     if (jintunwrapIntjintintID == NULL)
2179     {
2180         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapInt");
2181     }
2182
2183     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintunwrapIntjintintID , x));
2184     curEnv->DeleteLocalRef(cls);
2185     if (curEnv->ExceptionCheck())
2186     {
2187         throw GiwsException::JniCallMethodException(curEnv);
2188     }
2189     return res;
2190
2191 }
2192
2193 int* ScilabJavaObject::unwrapRowInt (JavaVM * jvm_, int x)
2194 {
2195
2196     JNIEnv * curEnv = NULL;
2197     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2198     jclass cls = curEnv->FindClass( className().c_str() );
2199     if ( cls == NULL)
2200     {
2201         throw GiwsException::JniCallMethodException(curEnv);
2202     }
2203
2204     jmethodID jintArray_unwrapRowIntjintintID = curEnv->GetStaticMethodID(cls, "unwrapRowInt", "(I)[I" ) ;
2205     if (jintArray_unwrapRowIntjintintID == NULL)
2206     {
2207         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapRowInt");
2208     }
2209
2210     jintArray res =  static_cast<jintArray>( curEnv->CallStaticObjectMethod(cls, jintArray_unwrapRowIntjintintID , x));
2211     if (res == NULL)
2212     {
2213         return NULL;
2214     }
2215     if (curEnv->ExceptionCheck())
2216     {
2217         throw GiwsException::JniCallMethodException(curEnv);
2218     }
2219     int lenRow;
2220     lenRow = curEnv->GetArrayLength(res);
2221     jboolean isCopy = JNI_FALSE;
2222
2223     /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
2224     jint *resultsArray = static_cast<jint *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
2225     int* myArray = new int[ lenRow];
2226
2227     for (jsize i = 0; i <  lenRow; i++)
2228     {
2229         myArray[i] = resultsArray[i];
2230     }
2231     curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
2232
2233     curEnv->DeleteLocalRef(res);
2234     curEnv->DeleteLocalRef(cls);
2235     if (curEnv->ExceptionCheck())
2236     {
2237         delete[] myArray;
2238         throw GiwsException::JniCallMethodException(curEnv);
2239     }
2240     return myArray;
2241
2242 }
2243
2244 int** ScilabJavaObject::unwrapMatInt (JavaVM * jvm_, int x)
2245 {
2246
2247     JNIEnv * curEnv = NULL;
2248     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2249     jclass cls = curEnv->FindClass( className().c_str() );
2250     if ( cls == NULL)
2251     {
2252         throw GiwsException::JniCallMethodException(curEnv);
2253     }
2254
2255     jmethodID jobjectArray__unwrapMatIntjintintID = curEnv->GetStaticMethodID(cls, "unwrapMatInt", "(I)[[I" ) ;
2256     if (jobjectArray__unwrapMatIntjintintID == NULL)
2257     {
2258         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapMatInt");
2259     }
2260
2261     jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray__unwrapMatIntjintintID , x));
2262     if (res == NULL)
2263     {
2264         return NULL;
2265     }
2266     if (curEnv->ExceptionCheck())
2267     {
2268         throw GiwsException::JniCallMethodException(curEnv);
2269     }
2270     int lenCol;
2271     int lenRow;
2272     lenRow = curEnv->GetArrayLength(res);
2273     jboolean isCopy = JNI_FALSE;
2274
2275     int ** myArray = new int*[ lenRow];
2276     for (int i = 0; i < lenRow; i++)
2277     {
2278         jintArray oneDim = (jintArray)curEnv->GetObjectArrayElement(res, i);
2279         lenCol = curEnv->GetArrayLength(oneDim);
2280         int *resultsArray = static_cast<int *>(curEnv->GetPrimitiveArrayCritical(oneDim, &isCopy));
2281         myArray[i] = new int[ lenCol];
2282         for (int j = 0; j < lenCol; j++)
2283         {
2284             myArray[i][j] = resultsArray[j];
2285         }
2286         curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
2287     }
2288
2289     curEnv->DeleteLocalRef(res);
2290     curEnv->DeleteLocalRef(cls);
2291     if (curEnv->ExceptionCheck())
2292     {
2293         delete[] myArray;
2294         throw GiwsException::JniCallMethodException(curEnv);
2295     }
2296     return myArray;
2297
2298 }
2299
2300 long long ScilabJavaObject::unwrapUInt (JavaVM * jvm_, int x)
2301 {
2302
2303     JNIEnv * curEnv = NULL;
2304     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2305     jclass cls = curEnv->FindClass( className().c_str() );
2306     if ( cls == NULL)
2307     {
2308         throw GiwsException::JniCallMethodException(curEnv);
2309     }
2310
2311     jmethodID jlongunwrapUIntjintintID = curEnv->GetStaticMethodID(cls, "unwrapUInt", "(I)J" ) ;
2312     if (jlongunwrapUIntjintintID == NULL)
2313     {
2314         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapUInt");
2315     }
2316
2317     jlong res =  static_cast<jlong>( curEnv->CallStaticLongMethod(cls, jlongunwrapUIntjintintID , x));
2318     curEnv->DeleteLocalRef(cls);
2319     if (curEnv->ExceptionCheck())
2320     {
2321         throw GiwsException::JniCallMethodException(curEnv);
2322     }
2323     return res;
2324
2325 }
2326
2327 long long* ScilabJavaObject::unwrapRowUInt (JavaVM * jvm_, int x)
2328 {
2329
2330     JNIEnv * curEnv = NULL;
2331     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2332     jclass cls = curEnv->FindClass( className().c_str() );
2333     if ( cls == NULL)
2334     {
2335         throw GiwsException::JniCallMethodException(curEnv);
2336     }
2337
2338     jmethodID jlongArray_unwrapRowUIntjintintID = curEnv->GetStaticMethodID(cls, "unwrapRowUInt", "(I)[J" ) ;
2339     if (jlongArray_unwrapRowUIntjintintID == NULL)
2340     {
2341         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapRowUInt");
2342     }
2343
2344     jlongArray res =  static_cast<jlongArray>( curEnv->CallStaticObjectMethod(cls, jlongArray_unwrapRowUIntjintintID , x));
2345     if (res == NULL)
2346     {
2347         return NULL;
2348     }
2349     if (curEnv->ExceptionCheck())
2350     {
2351         throw GiwsException::JniCallMethodException(curEnv);
2352     }
2353     int lenRow;
2354     lenRow = curEnv->GetArrayLength(res);
2355     jboolean isCopy = JNI_FALSE;
2356
2357     /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
2358     jlong *resultsArray = static_cast<jlong *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
2359     long long* myArray = new long long[ lenRow];
2360
2361     for (jsize i = 0; i <  lenRow; i++)
2362     {
2363         myArray[i] = resultsArray[i];
2364     }
2365     curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
2366
2367     curEnv->DeleteLocalRef(res);
2368     curEnv->DeleteLocalRef(cls);
2369     if (curEnv->ExceptionCheck())
2370     {
2371         delete[] myArray;
2372         throw GiwsException::JniCallMethodException(curEnv);
2373     }
2374     return myArray;
2375
2376 }
2377
2378 long long** ScilabJavaObject::unwrapMatUInt (JavaVM * jvm_, int x)
2379 {
2380
2381     JNIEnv * curEnv = NULL;
2382     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2383     jclass cls = curEnv->FindClass( className().c_str() );
2384     if ( cls == NULL)
2385     {
2386         throw GiwsException::JniCallMethodException(curEnv);
2387     }
2388
2389     jmethodID jobjectArray__unwrapMatUIntjintintID = curEnv->GetStaticMethodID(cls, "unwrapMatUInt", "(I)[[J" ) ;
2390     if (jobjectArray__unwrapMatUIntjintintID == NULL)
2391     {
2392         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapMatUInt");
2393     }
2394
2395     jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray__unwrapMatUIntjintintID , x));
2396     if (res == NULL)
2397     {
2398         return NULL;
2399     }
2400     if (curEnv->ExceptionCheck())
2401     {
2402         throw GiwsException::JniCallMethodException(curEnv);
2403     }
2404     int lenCol;
2405     int lenRow;
2406     lenRow = curEnv->GetArrayLength(res);
2407     jboolean isCopy = JNI_FALSE;
2408
2409     long long ** myArray = new long long*[ lenRow];
2410     for (int i = 0; i < lenRow; i++)
2411     {
2412         jlongArray oneDim = (jlongArray)curEnv->GetObjectArrayElement(res, i);
2413         lenCol = curEnv->GetArrayLength(oneDim);
2414         long long *resultsArray = static_cast<long long *>(curEnv->GetPrimitiveArrayCritical(oneDim, &isCopy));
2415         myArray[i] = new long long[ lenCol];
2416         for (int j = 0; j < lenCol; j++)
2417         {
2418             myArray[i][j] = resultsArray[j];
2419         }
2420         curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
2421     }
2422
2423     curEnv->DeleteLocalRef(res);
2424     curEnv->DeleteLocalRef(cls);
2425     if (curEnv->ExceptionCheck())
2426     {
2427         delete[] myArray;
2428         throw GiwsException::JniCallMethodException(curEnv);
2429     }
2430     return myArray;
2431
2432 }
2433
2434 byte ScilabJavaObject::unwrapByte (JavaVM * jvm_, int x)
2435 {
2436
2437     JNIEnv * curEnv = NULL;
2438     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2439     jclass cls = curEnv->FindClass( className().c_str() );
2440     if ( cls == NULL)
2441     {
2442         throw GiwsException::JniCallMethodException(curEnv);
2443     }
2444
2445     jmethodID jbyteunwrapBytejintintID = curEnv->GetStaticMethodID(cls, "unwrapByte", "(I)B" ) ;
2446     if (jbyteunwrapBytejintintID == NULL)
2447     {
2448         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapByte");
2449     }
2450
2451     jbyte res =  static_cast<jbyte>( curEnv->CallStaticByteMethod(cls, jbyteunwrapBytejintintID , x));
2452     curEnv->DeleteLocalRef(cls);
2453     if (curEnv->ExceptionCheck())
2454     {
2455         throw GiwsException::JniCallMethodException(curEnv);
2456     }
2457     return res;
2458
2459 }
2460
2461 byte* ScilabJavaObject::unwrapRowByte (JavaVM * jvm_, int x)
2462 {
2463
2464     JNIEnv * curEnv = NULL;
2465     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2466     jclass cls = curEnv->FindClass( className().c_str() );
2467     if ( cls == NULL)
2468     {
2469         throw GiwsException::JniCallMethodException(curEnv);
2470     }
2471
2472     jmethodID jbyteArray_unwrapRowBytejintintID = curEnv->GetStaticMethodID(cls, "unwrapRowByte", "(I)[B" ) ;
2473     if (jbyteArray_unwrapRowBytejintintID == NULL)
2474     {
2475         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapRowByte");
2476     }
2477
2478     jbyteArray res =  static_cast<jbyteArray>( curEnv->CallStaticObjectMethod(cls, jbyteArray_unwrapRowBytejintintID , x));
2479     if (res == NULL)
2480     {
2481         return NULL;
2482     }
2483     if (curEnv->ExceptionCheck())
2484     {
2485         throw GiwsException::JniCallMethodException(curEnv);
2486     }
2487     int lenRow;
2488     lenRow = curEnv->GetArrayLength(res);
2489     jboolean isCopy = JNI_FALSE;
2490
2491     /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
2492     jbyte *resultsArray = static_cast<jbyte *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
2493     byte* myArray = new byte[ lenRow];
2494
2495     for (jsize i = 0; i <  lenRow; i++)
2496     {
2497         myArray[i] = resultsArray[i];
2498     }
2499     curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
2500
2501     curEnv->DeleteLocalRef(res);
2502     curEnv->DeleteLocalRef(cls);
2503     if (curEnv->ExceptionCheck())
2504     {
2505         delete[] myArray;
2506         throw GiwsException::JniCallMethodException(curEnv);
2507     }
2508     return myArray;
2509
2510 }
2511
2512 byte** ScilabJavaObject::unwrapMatByte (JavaVM * jvm_, int x)
2513 {
2514
2515     JNIEnv * curEnv = NULL;
2516     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2517     jclass cls = curEnv->FindClass( className().c_str() );
2518     if ( cls == NULL)
2519     {
2520         throw GiwsException::JniCallMethodException(curEnv);
2521     }
2522
2523     jmethodID jobjectArray__unwrapMatBytejintintID = curEnv->GetStaticMethodID(cls, "unwrapMatByte", "(I)[[B" ) ;
2524     if (jobjectArray__unwrapMatBytejintintID == NULL)
2525     {
2526         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapMatByte");
2527     }
2528
2529     jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray__unwrapMatBytejintintID , x));
2530     if (res == NULL)
2531     {
2532         return NULL;
2533     }
2534     if (curEnv->ExceptionCheck())
2535     {
2536         throw GiwsException::JniCallMethodException(curEnv);
2537     }
2538     int lenCol;
2539     int lenRow;
2540     lenRow = curEnv->GetArrayLength(res);
2541     jboolean isCopy = JNI_FALSE;
2542
2543     byte ** myArray = new byte*[ lenRow];
2544     for (int i = 0; i < lenRow; i++)
2545     {
2546         jbyteArray oneDim = (jbyteArray)curEnv->GetObjectArrayElement(res, i);
2547         lenCol = curEnv->GetArrayLength(oneDim);
2548         byte *resultsArray = static_cast<byte *>(curEnv->GetPrimitiveArrayCritical(oneDim, &isCopy));
2549         myArray[i] = new byte[ lenCol];
2550         for (int j = 0; j < lenCol; j++)
2551         {
2552             myArray[i][j] = resultsArray[j];
2553         }
2554         curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
2555     }
2556
2557     curEnv->DeleteLocalRef(res);
2558     curEnv->DeleteLocalRef(cls);
2559     if (curEnv->ExceptionCheck())
2560     {
2561         delete[] myArray;
2562         throw GiwsException::JniCallMethodException(curEnv);
2563     }
2564     return myArray;
2565
2566 }
2567
2568 short ScilabJavaObject::unwrapUByte (JavaVM * jvm_, int x)
2569 {
2570
2571     JNIEnv * curEnv = NULL;
2572     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2573     jclass cls = curEnv->FindClass( className().c_str() );
2574     if ( cls == NULL)
2575     {
2576         throw GiwsException::JniCallMethodException(curEnv);
2577     }
2578
2579     jmethodID jshortunwrapUBytejintintID = curEnv->GetStaticMethodID(cls, "unwrapUByte", "(I)S" ) ;
2580     if (jshortunwrapUBytejintintID == NULL)
2581     {
2582         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapUByte");
2583     }
2584
2585     jshort res =  static_cast<jshort>( curEnv->CallStaticShortMethod(cls, jshortunwrapUBytejintintID , x));
2586     curEnv->DeleteLocalRef(cls);
2587     if (curEnv->ExceptionCheck())
2588     {
2589         throw GiwsException::JniCallMethodException(curEnv);
2590     }
2591     return res;
2592
2593 }
2594
2595 short* ScilabJavaObject::unwrapRowUByte (JavaVM * jvm_, int x)
2596 {
2597
2598     JNIEnv * curEnv = NULL;
2599     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2600     jclass cls = curEnv->FindClass( className().c_str() );
2601     if ( cls == NULL)
2602     {
2603         throw GiwsException::JniCallMethodException(curEnv);
2604     }
2605
2606     jmethodID jshortArray_unwrapRowUBytejintintID = curEnv->GetStaticMethodID(cls, "unwrapRowUByte", "(I)[S" ) ;
2607     if (jshortArray_unwrapRowUBytejintintID == NULL)
2608     {
2609         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapRowUByte");
2610     }
2611
2612     jshortArray res =  static_cast<jshortArray>( curEnv->CallStaticObjectMethod(cls, jshortArray_unwrapRowUBytejintintID , x));
2613     if (res == NULL)
2614     {
2615         return NULL;
2616     }
2617     if (curEnv->ExceptionCheck())
2618     {
2619         throw GiwsException::JniCallMethodException(curEnv);
2620     }
2621     int lenRow;
2622     lenRow = curEnv->GetArrayLength(res);
2623     jboolean isCopy = JNI_FALSE;
2624
2625     /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
2626     jshort *resultsArray = static_cast<jshort *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
2627     short* myArray = new short[ lenRow];
2628
2629     for (jsize i = 0; i <  lenRow; i++)
2630     {
2631         myArray[i] = resultsArray[i];
2632     }
2633     curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
2634
2635     curEnv->DeleteLocalRef(res);
2636     curEnv->DeleteLocalRef(cls);
2637     if (curEnv->ExceptionCheck())
2638     {
2639         delete[] myArray;
2640         throw GiwsException::JniCallMethodException(curEnv);
2641     }
2642     return myArray;
2643
2644 }
2645
2646 short** ScilabJavaObject::unwrapMatUByte (JavaVM * jvm_, int x)
2647 {
2648
2649     JNIEnv * curEnv = NULL;
2650     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2651     jclass cls = curEnv->FindClass( className().c_str() );
2652     if ( cls == NULL)
2653     {
2654         throw GiwsException::JniCallMethodException(curEnv);
2655     }
2656
2657     jmethodID jobjectArray__unwrapMatUBytejintintID = curEnv->GetStaticMethodID(cls, "unwrapMatUByte", "(I)[[S" ) ;
2658     if (jobjectArray__unwrapMatUBytejintintID == NULL)
2659     {
2660         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapMatUByte");
2661     }
2662
2663     jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray__unwrapMatUBytejintintID , x));
2664     if (res == NULL)
2665     {
2666         return NULL;
2667     }
2668     if (curEnv->ExceptionCheck())
2669     {
2670         throw GiwsException::JniCallMethodException(curEnv);
2671     }
2672     int lenCol;
2673     int lenRow;
2674     lenRow = curEnv->GetArrayLength(res);
2675     jboolean isCopy = JNI_FALSE;
2676
2677     short ** myArray = new short*[ lenRow];
2678     for (int i = 0; i < lenRow; i++)
2679     {
2680         jshortArray oneDim = (jshortArray)curEnv->GetObjectArrayElement(res, i);
2681         lenCol = curEnv->GetArrayLength(oneDim);
2682         short *resultsArray = static_cast<short *>(curEnv->GetPrimitiveArrayCritical(oneDim, &isCopy));
2683         myArray[i] = new short[ lenCol];
2684         for (int j = 0; j < lenCol; j++)
2685         {
2686             myArray[i][j] = resultsArray[j];
2687         }
2688         curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
2689     }
2690
2691     curEnv->DeleteLocalRef(res);
2692     curEnv->DeleteLocalRef(cls);
2693     if (curEnv->ExceptionCheck())
2694     {
2695         delete[] myArray;
2696         throw GiwsException::JniCallMethodException(curEnv);
2697     }
2698     return myArray;
2699
2700 }
2701
2702 short ScilabJavaObject::unwrapShort (JavaVM * jvm_, int x)
2703 {
2704
2705     JNIEnv * curEnv = NULL;
2706     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2707     jclass cls = curEnv->FindClass( className().c_str() );
2708     if ( cls == NULL)
2709     {
2710         throw GiwsException::JniCallMethodException(curEnv);
2711     }
2712
2713     jmethodID jshortunwrapShortjintintID = curEnv->GetStaticMethodID(cls, "unwrapShort", "(I)S" ) ;
2714     if (jshortunwrapShortjintintID == NULL)
2715     {
2716         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapShort");
2717     }
2718
2719     jshort res =  static_cast<jshort>( curEnv->CallStaticShortMethod(cls, jshortunwrapShortjintintID , x));
2720     curEnv->DeleteLocalRef(cls);
2721     if (curEnv->ExceptionCheck())
2722     {
2723         throw GiwsException::JniCallMethodException(curEnv);
2724     }
2725     return res;
2726
2727 }
2728
2729 short* ScilabJavaObject::unwrapRowShort (JavaVM * jvm_, int x)
2730 {
2731
2732     JNIEnv * curEnv = NULL;
2733     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2734     jclass cls = curEnv->FindClass( className().c_str() );
2735     if ( cls == NULL)
2736     {
2737         throw GiwsException::JniCallMethodException(curEnv);
2738     }
2739
2740     jmethodID jshortArray_unwrapRowShortjintintID = curEnv->GetStaticMethodID(cls, "unwrapRowShort", "(I)[S" ) ;
2741     if (jshortArray_unwrapRowShortjintintID == NULL)
2742     {
2743         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapRowShort");
2744     }
2745
2746     jshortArray res =  static_cast<jshortArray>( curEnv->CallStaticObjectMethod(cls, jshortArray_unwrapRowShortjintintID , x));
2747     if (res == NULL)
2748     {
2749         return NULL;
2750     }
2751     if (curEnv->ExceptionCheck())
2752     {
2753         throw GiwsException::JniCallMethodException(curEnv);
2754     }
2755     int lenRow;
2756     lenRow = curEnv->GetArrayLength(res);
2757     jboolean isCopy = JNI_FALSE;
2758
2759     /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
2760     jshort *resultsArray = static_cast<jshort *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
2761     short* myArray = new short[ lenRow];
2762
2763     for (jsize i = 0; i <  lenRow; i++)
2764     {
2765         myArray[i] = resultsArray[i];
2766     }
2767     curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
2768
2769     curEnv->DeleteLocalRef(res);
2770     curEnv->DeleteLocalRef(cls);
2771     if (curEnv->ExceptionCheck())
2772     {
2773         delete[] myArray;
2774         throw GiwsException::JniCallMethodException(curEnv);
2775     }
2776     return myArray;
2777
2778 }
2779
2780 short** ScilabJavaObject::unwrapMatShort (JavaVM * jvm_, int x)
2781 {
2782
2783     JNIEnv * curEnv = NULL;
2784     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2785     jclass cls = curEnv->FindClass( className().c_str() );
2786     if ( cls == NULL)
2787     {
2788         throw GiwsException::JniCallMethodException(curEnv);
2789     }
2790
2791     jmethodID jobjectArray__unwrapMatShortjintintID = curEnv->GetStaticMethodID(cls, "unwrapMatShort", "(I)[[S" ) ;
2792     if (jobjectArray__unwrapMatShortjintintID == NULL)
2793     {
2794         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapMatShort");
2795     }
2796
2797     jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray__unwrapMatShortjintintID , x));
2798     if (res == NULL)
2799     {
2800         return NULL;
2801     }
2802     if (curEnv->ExceptionCheck())
2803     {
2804         throw GiwsException::JniCallMethodException(curEnv);
2805     }
2806     int lenCol;
2807     int lenRow;
2808     lenRow = curEnv->GetArrayLength(res);
2809     jboolean isCopy = JNI_FALSE;
2810
2811     short ** myArray = new short*[ lenRow];
2812     for (int i = 0; i < lenRow; i++)
2813     {
2814         jshortArray oneDim = (jshortArray)curEnv->GetObjectArrayElement(res, i);
2815         lenCol = curEnv->GetArrayLength(oneDim);
2816         short *resultsArray = static_cast<short *>(curEnv->GetPrimitiveArrayCritical(oneDim, &isCopy));
2817         myArray[i] = new short[ lenCol];
2818         for (int j = 0; j < lenCol; j++)
2819         {
2820             myArray[i][j] = resultsArray[j];
2821         }
2822         curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
2823     }
2824
2825     curEnv->DeleteLocalRef(res);
2826     curEnv->DeleteLocalRef(cls);
2827     if (curEnv->ExceptionCheck())
2828     {
2829         delete[] myArray;
2830         throw GiwsException::JniCallMethodException(curEnv);
2831     }
2832     return myArray;
2833
2834 }
2835
2836 int ScilabJavaObject::unwrapUShort (JavaVM * jvm_, int x)
2837 {
2838
2839     JNIEnv * curEnv = NULL;
2840     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2841     jclass cls = curEnv->FindClass( className().c_str() );
2842     if ( cls == NULL)
2843     {
2844         throw GiwsException::JniCallMethodException(curEnv);
2845     }
2846
2847     jmethodID jintunwrapUShortjintintID = curEnv->GetStaticMethodID(cls, "unwrapUShort", "(I)I" ) ;
2848     if (jintunwrapUShortjintintID == NULL)
2849     {
2850         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapUShort");
2851     }
2852
2853     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintunwrapUShortjintintID , x));
2854     curEnv->DeleteLocalRef(cls);
2855     if (curEnv->ExceptionCheck())
2856     {
2857         throw GiwsException::JniCallMethodException(curEnv);
2858     }
2859     return res;
2860
2861 }
2862
2863 int* ScilabJavaObject::unwrapRowUShort (JavaVM * jvm_, int x)
2864 {
2865
2866     JNIEnv * curEnv = NULL;
2867     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2868     jclass cls = curEnv->FindClass( className().c_str() );
2869     if ( cls == NULL)
2870     {
2871         throw GiwsException::JniCallMethodException(curEnv);
2872     }
2873
2874     jmethodID jintArray_unwrapRowUShortjintintID = curEnv->GetStaticMethodID(cls, "unwrapRowUShort", "(I)[I" ) ;
2875     if (jintArray_unwrapRowUShortjintintID == NULL)
2876     {
2877         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapRowUShort");
2878     }
2879
2880     jintArray res =  static_cast<jintArray>( curEnv->CallStaticObjectMethod(cls, jintArray_unwrapRowUShortjintintID , x));
2881     if (res == NULL)
2882     {
2883         return NULL;
2884     }
2885     if (curEnv->ExceptionCheck())
2886     {
2887         throw GiwsException::JniCallMethodException(curEnv);
2888     }
2889     int lenRow;
2890     lenRow = curEnv->GetArrayLength(res);
2891     jboolean isCopy = JNI_FALSE;
2892
2893     /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
2894     jint *resultsArray = static_cast<jint *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
2895     int* myArray = new int[ lenRow];
2896
2897     for (jsize i = 0; i <  lenRow; i++)
2898     {
2899         myArray[i] = resultsArray[i];
2900     }
2901     curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
2902
2903     curEnv->DeleteLocalRef(res);
2904     curEnv->DeleteLocalRef(cls);
2905     if (curEnv->ExceptionCheck())
2906     {
2907         delete[] myArray;
2908         throw GiwsException::JniCallMethodException(curEnv);
2909     }
2910     return myArray;
2911
2912 }
2913
2914 int** ScilabJavaObject::unwrapMatUShort (JavaVM * jvm_, int x)
2915 {
2916
2917     JNIEnv * curEnv = NULL;
2918     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2919     jclass cls = curEnv->FindClass( className().c_str() );
2920     if ( cls == NULL)
2921     {
2922         throw GiwsException::JniCallMethodException(curEnv);
2923     }
2924
2925     jmethodID jobjectArray__unwrapMatUShortjintintID = curEnv->GetStaticMethodID(cls, "unwrapMatUShort", "(I)[[I" ) ;
2926     if (jobjectArray__unwrapMatUShortjintintID == NULL)
2927     {
2928         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapMatUShort");
2929     }
2930
2931     jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray__unwrapMatUShortjintintID , x));
2932     if (res == NULL)
2933     {
2934         return NULL;
2935     }
2936     if (curEnv->ExceptionCheck())
2937     {
2938         throw GiwsException::JniCallMethodException(curEnv);
2939     }
2940     int lenCol;
2941     int lenRow;
2942     lenRow = curEnv->GetArrayLength(res);
2943     jboolean isCopy = JNI_FALSE;
2944
2945     int ** myArray = new int*[ lenRow];
2946     for (int i = 0; i < lenRow; i++)
2947     {
2948         jintArray oneDim = (jintArray)curEnv->GetObjectArrayElement(res, i);
2949         lenCol = curEnv->GetArrayLength(oneDim);
2950         int *resultsArray = static_cast<int *>(curEnv->GetPrimitiveArrayCritical(oneDim, &isCopy));
2951         myArray[i] = new int[ lenCol];
2952         for (int j = 0; j < lenCol; j++)
2953         {
2954             myArray[i][j] = resultsArray[j];
2955         }
2956         curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
2957     }
2958
2959     curEnv->DeleteLocalRef(res);
2960     curEnv->DeleteLocalRef(cls);
2961     if (curEnv->ExceptionCheck())
2962     {
2963         delete[] myArray;
2964         throw GiwsException::JniCallMethodException(curEnv);
2965     }
2966     return myArray;
2967
2968 }
2969
2970 char* ScilabJavaObject::unwrapString (JavaVM * jvm_, int x)
2971 {
2972
2973     JNIEnv * curEnv = NULL;
2974     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2975     jclass cls = curEnv->FindClass( className().c_str() );
2976     if ( cls == NULL)
2977     {
2978         throw GiwsException::JniCallMethodException(curEnv);
2979     }
2980
2981     jmethodID jstringunwrapStringjintintID = curEnv->GetStaticMethodID(cls, "unwrapString", "(I)Ljava/lang/String;" ) ;
2982     if (jstringunwrapStringjintintID == NULL)
2983     {
2984         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapString");
2985     }
2986
2987     jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringunwrapStringjintintID , x));
2988     if (curEnv->ExceptionCheck())
2989     {
2990         throw GiwsException::JniCallMethodException(curEnv);
2991     }
2992     if (res != NULL)
2993     {
2994
2995         const char *tempString = curEnv->GetStringUTFChars(res, 0);
2996         char * myStringBuffer = new char[strlen(tempString) + 1];
2997         strcpy(myStringBuffer, tempString);
2998         curEnv->ReleaseStringUTFChars(res, tempString);
2999         curEnv->DeleteLocalRef(res);
3000         curEnv->DeleteLocalRef(cls);
3001         if (curEnv->ExceptionCheck())
3002         {
3003             delete[] myStringBuffer;
3004             throw GiwsException::JniCallMethodException(curEnv);
3005         }
3006         return myStringBuffer;
3007     }
3008     else
3009     {
3010         curEnv->DeleteLocalRef(res);
3011         return NULL;
3012     }
3013 }
3014
3015 char** ScilabJavaObject::unwrapRowString (JavaVM * jvm_, int x)
3016 {
3017
3018     JNIEnv * curEnv = NULL;
3019     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3020     jclass cls = curEnv->FindClass( className().c_str() );
3021     if ( cls == NULL)
3022     {
3023         throw GiwsException::JniCallMethodException(curEnv);
3024     }
3025
3026     jmethodID jobjectArray_unwrapRowStringjintintID = curEnv->GetStaticMethodID(cls, "unwrapRowString", "(I)[Ljava/lang/String;" ) ;
3027     if (jobjectArray_unwrapRowStringjintintID == NULL)
3028     {
3029         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapRowString");
3030     }
3031
3032     jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray_unwrapRowStringjintintID , x));
3033     if (curEnv->ExceptionCheck())
3034     {
3035         throw GiwsException::JniCallMethodException(curEnv);
3036     }
3037     if (res != NULL)
3038     {
3039         int lenRow;
3040         lenRow = curEnv->GetArrayLength(res);
3041
3042         char **arrayOfString;
3043         arrayOfString = new char *[lenRow];
3044         for (jsize i = 0; i < lenRow; i++)
3045         {
3046             jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
3047             const char *tempString = curEnv->GetStringUTFChars(resString, 0);
3048             arrayOfString[i] = new char[strlen(tempString) + 1];
3049
3050             strcpy(arrayOfString[i], tempString);
3051             curEnv->ReleaseStringUTFChars(resString, tempString);
3052             curEnv->DeleteLocalRef(resString);
3053         }
3054         curEnv->DeleteLocalRef(cls);
3055         if (curEnv->ExceptionCheck())
3056         {
3057             delete[] arrayOfString;
3058             throw GiwsException::JniCallMethodException(curEnv);
3059         }
3060         curEnv->DeleteLocalRef(res);
3061         return arrayOfString;
3062     }
3063     else
3064     {
3065         curEnv->DeleteLocalRef(res);
3066         return NULL;
3067     }
3068 }
3069
3070 char*** ScilabJavaObject::unwrapMatString (JavaVM * jvm_, int x)
3071 {
3072
3073     JNIEnv * curEnv = NULL;
3074     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3075     jclass cls = curEnv->FindClass( className().c_str() );
3076     if ( cls == NULL)
3077     {
3078         throw GiwsException::JniCallMethodException(curEnv);
3079     }
3080
3081     jmethodID jobjectArray__unwrapMatStringjintintID = curEnv->GetStaticMethodID(cls, "unwrapMatString", "(I)[[Ljava/lang/String;" ) ;
3082     if (jobjectArray__unwrapMatStringjintintID == NULL)
3083     {
3084         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapMatString");
3085     }
3086
3087     jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray__unwrapMatStringjintintID , x));
3088     if (curEnv->ExceptionCheck())
3089     {
3090         throw GiwsException::JniCallMethodException(curEnv);
3091     }
3092     if (res != NULL)
3093     {
3094         int lenCol;
3095         int lenRow;
3096         lenRow = curEnv->GetArrayLength(res);
3097
3098         char ***arrayOfString;
3099         arrayOfString = new char **[lenRow];
3100         for (jsize i = 0; i < lenRow; i++)  /* Line of the array */
3101         {
3102             jobjectArray resStringLine = reinterpret_cast<jobjectArray>(curEnv->GetObjectArrayElement(res, i));
3103             lenCol = curEnv->GetArrayLength(resStringLine);
3104             arrayOfString[i] = new char*[lenCol];
3105             for (jsize j = 0; j < lenCol; j++)
3106             {
3107                 jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(resStringLine, j));
3108                 const char *tempString = curEnv->GetStringUTFChars(resString, 0);
3109                 arrayOfString[i][j] = new char[strlen(tempString) + 1];
3110                 strcpy(arrayOfString[i][j], tempString);
3111                 curEnv->ReleaseStringUTFChars(resString, tempString);
3112                 curEnv->DeleteLocalRef(resString);
3113             }
3114             curEnv->DeleteLocalRef(resStringLine);
3115         }
3116         curEnv->DeleteLocalRef(cls);
3117         if (curEnv->ExceptionCheck())
3118         {
3119             delete[] arrayOfString;
3120             throw GiwsException::JniCallMethodException(curEnv);
3121         }
3122         curEnv->DeleteLocalRef(res);
3123         return arrayOfString;
3124     }
3125     else
3126     {
3127         curEnv->DeleteLocalRef(res);
3128         return NULL;
3129     }
3130 }
3131
3132 bool ScilabJavaObject::unwrapBoolean (JavaVM * jvm_, int x)
3133 {
3134
3135     JNIEnv * curEnv = NULL;
3136     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3137     jclass cls = curEnv->FindClass( className().c_str() );
3138     if ( cls == NULL)
3139     {
3140         throw GiwsException::JniCallMethodException(curEnv);
3141     }
3142
3143     jmethodID jbooleanunwrapBooleanjintintID = curEnv->GetStaticMethodID(cls, "unwrapBoolean", "(I)Z" ) ;
3144     if (jbooleanunwrapBooleanjintintID == NULL)
3145     {
3146         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapBoolean");
3147     }
3148
3149     jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanunwrapBooleanjintintID , x));
3150     curEnv->DeleteLocalRef(cls);
3151     if (curEnv->ExceptionCheck())
3152     {
3153         throw GiwsException::JniCallMethodException(curEnv);
3154     }
3155     return (res == JNI_TRUE);
3156
3157 }
3158
3159 bool* ScilabJavaObject::unwrapRowBoolean (JavaVM * jvm_, int x)
3160 {
3161
3162     JNIEnv * curEnv = NULL;
3163     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3164     jclass cls = curEnv->FindClass( className().c_str() );
3165     if ( cls == NULL)
3166     {
3167         throw GiwsException::JniCallMethodException(curEnv);
3168     }
3169
3170     jmethodID jbooleanArray_unwrapRowBooleanjintintID = curEnv->GetStaticMethodID(cls, "unwrapRowBoolean", "(I)[Z" ) ;
3171     if (jbooleanArray_unwrapRowBooleanjintintID == NULL)
3172     {
3173         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapRowBoolean");
3174     }
3175
3176     jbooleanArray res =  static_cast<jbooleanArray>( curEnv->CallStaticObjectMethod(cls, jbooleanArray_unwrapRowBooleanjintintID , x));
3177     if (curEnv->ExceptionCheck())
3178     {
3179         throw GiwsException::JniCallMethodException(curEnv);
3180     }
3181     int *lenRow;
3182     *lenRow = curEnv->GetArrayLength(res);
3183     jboolean isCopy = JNI_FALSE;
3184
3185
3186     /* faster than getXXXArrayElements */
3187     jboolean *resultsArray = static_cast<jboolean *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
3188     bool * myArray = new bool[*lenRow];
3189
3190     for (jsize i = 0; i < *lenRow; i++)
3191     {
3192         myArray[i] = (resultsArray[i] == JNI_TRUE);
3193     }
3194     curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
3195
3196     curEnv->DeleteLocalRef(res);
3197     curEnv->DeleteLocalRef(cls);
3198     if (curEnv->ExceptionCheck())
3199     {
3200         delete[] myArray;
3201         throw GiwsException::JniCallMethodException(curEnv);
3202     }
3203     return myArray;
3204
3205 }
3206
3207 bool** ScilabJavaObject::unwrapMatBoolean (JavaVM * jvm_, int x)
3208 {
3209
3210     JNIEnv * curEnv = NULL;
3211     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3212     jclass cls = curEnv->FindClass( className().c_str() );
3213     if ( cls == NULL)
3214     {
3215         throw GiwsException::JniCallMethodException(curEnv);
3216     }
3217
3218     jmethodID jobjectArray__unwrapMatBooleanjintintID = curEnv->GetStaticMethodID(cls, "unwrapMatBoolean", "(I)[[Z" ) ;
3219     if (jobjectArray__unwrapMatBooleanjintintID == NULL)
3220     {
3221         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapMatBoolean");
3222     }
3223
3224     jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray__unwrapMatBooleanjintintID , x));
3225     if (curEnv->ExceptionCheck())
3226     {
3227         throw GiwsException::JniCallMethodException(curEnv);
3228     }
3229     int *lenCol;
3230     int *lenRow;
3231     *lenRow = curEnv->GetArrayLength(res);
3232     jboolean isCopy = JNI_FALSE;
3233
3234     bool ** myArray = new bool*[*lenRow];
3235     for (int i = 0; i < *lenRow; i++)
3236     {
3237         jbooleanArray oneDim = (jbooleanArray)curEnv->GetObjectArrayElement(res, i);
3238         *lenCol = curEnv->GetArrayLength(oneDim);
3239         bool *resultsArray = static_cast<bool *>(curEnv->GetPrimitiveArrayCritical(oneDim, &isCopy));
3240         myArray[i] = new bool[*lenCol];
3241         for (int j = 0; j < *lenCol; j++)
3242         {
3243             myArray[i][j] = (resultsArray[j] == JNI_TRUE);
3244         }
3245         curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
3246     }
3247
3248     curEnv->DeleteLocalRef(res);
3249     curEnv->DeleteLocalRef(cls);
3250     if (curEnv->ExceptionCheck())
3251     {
3252         delete[] myArray;
3253         throw GiwsException::JniCallMethodException(curEnv);
3254     }
3255     return myArray;
3256
3257 }
3258
3259 unsigned short ScilabJavaObject::unwrapChar (JavaVM * jvm_, int x)
3260 {
3261
3262     JNIEnv * curEnv = NULL;
3263     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3264     jclass cls = curEnv->FindClass( className().c_str() );
3265     if ( cls == NULL)
3266     {
3267         throw GiwsException::JniCallMethodException(curEnv);
3268     }
3269
3270     jmethodID jcharunwrapCharjintintID = curEnv->GetStaticMethodID(cls, "unwrapChar", "(I)C" ) ;
3271     if (jcharunwrapCharjintintID == NULL)
3272     {
3273         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapChar");
3274     }
3275
3276     jchar res =  static_cast<jchar>( curEnv->CallStaticCharMethod(cls, jcharunwrapCharjintintID , x));
3277     curEnv->DeleteLocalRef(cls);
3278     if (curEnv->ExceptionCheck())
3279     {
3280         throw GiwsException::JniCallMethodException(curEnv);
3281     }
3282     return res;
3283
3284 }
3285
3286 unsigned short* ScilabJavaObject::unwrapRowChar (JavaVM * jvm_, int x)
3287 {
3288
3289     JNIEnv * curEnv = NULL;
3290     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3291     jclass cls = curEnv->FindClass( className().c_str() );
3292     if ( cls == NULL)
3293     {
3294         throw GiwsException::JniCallMethodException(curEnv);
3295     }
3296
3297     jmethodID jcharArray_unwrapRowCharjintintID = curEnv->GetStaticMethodID(cls, "unwrapRowChar", "(I)[C" ) ;
3298     if (jcharArray_unwrapRowCharjintintID == NULL)
3299     {
3300         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapRowChar");
3301     }
3302
3303     jcharArray res =  static_cast<jcharArray>( curEnv->CallStaticObjectMethod(cls, jcharArray_unwrapRowCharjintintID , x));
3304     if (res == NULL)
3305     {
3306         return NULL;
3307     }
3308     if (curEnv->ExceptionCheck())
3309     {
3310         throw GiwsException::JniCallMethodException(curEnv);
3311     }
3312     int lenRow;
3313     lenRow = curEnv->GetArrayLength(res);
3314     jboolean isCopy = JNI_FALSE;
3315
3316     /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
3317     jchar *resultsArray = static_cast<jchar *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
3318     unsigned short* myArray = new unsigned short[ lenRow];
3319
3320     for (jsize i = 0; i <  lenRow; i++)
3321     {
3322         myArray[i] = resultsArray[i];
3323     }
3324     curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
3325
3326     curEnv->DeleteLocalRef(res);
3327     curEnv->DeleteLocalRef(cls);
3328     if (curEnv->ExceptionCheck())
3329     {
3330         delete[] myArray;
3331         throw GiwsException::JniCallMethodException(curEnv);
3332     }
3333     return myArray;
3334
3335 }
3336
3337 unsigned short** ScilabJavaObject::unwrapMatChar (JavaVM * jvm_, int x)
3338 {
3339
3340     JNIEnv * curEnv = NULL;
3341     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3342     jclass cls = curEnv->FindClass( className().c_str() );
3343     if ( cls == NULL)
3344     {
3345         throw GiwsException::JniCallMethodException(curEnv);
3346     }
3347
3348     jmethodID jobjectArray__unwrapMatCharjintintID = curEnv->GetStaticMethodID(cls, "unwrapMatChar", "(I)[[C" ) ;
3349     if (jobjectArray__unwrapMatCharjintintID == NULL)
3350     {
3351         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapMatChar");
3352     }
3353
3354     jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray__unwrapMatCharjintintID , x));
3355     if (res == NULL)
3356     {
3357         return NULL;
3358     }
3359     if (curEnv->ExceptionCheck())
3360     {
3361         throw GiwsException::JniCallMethodException(curEnv);
3362     }
3363     int lenCol;
3364     int lenRow;
3365     lenRow = curEnv->GetArrayLength(res);
3366     jboolean isCopy = JNI_FALSE;
3367
3368     unsigned short ** myArray = new unsigned short*[ lenRow];
3369     for (int i = 0; i < lenRow; i++)
3370     {
3371         jcharArray oneDim = (jcharArray)curEnv->GetObjectArrayElement(res, i);
3372         lenCol = curEnv->GetArrayLength(oneDim);
3373         unsigned short *resultsArray = static_cast<unsigned short *>(curEnv->GetPrimitiveArrayCritical(oneDim, &isCopy));
3374         myArray[i] = new unsigned short[ lenCol];
3375         for (int j = 0; j < lenCol; j++)
3376         {
3377             myArray[i][j] = resultsArray[j];
3378         }
3379         curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
3380     }
3381
3382     curEnv->DeleteLocalRef(res);
3383     curEnv->DeleteLocalRef(cls);
3384     if (curEnv->ExceptionCheck())
3385     {
3386         delete[] myArray;
3387         throw GiwsException::JniCallMethodException(curEnv);
3388     }
3389     return myArray;
3390
3391 }
3392
3393 float ScilabJavaObject::unwrapFloat (JavaVM * jvm_, int x)
3394 {
3395
3396     JNIEnv * curEnv = NULL;
3397     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3398     jclass cls = curEnv->FindClass( className().c_str() );
3399     if ( cls == NULL)
3400     {
3401         throw GiwsException::JniCallMethodException(curEnv);
3402     }
3403
3404     jmethodID jfloatunwrapFloatjintintID = curEnv->GetStaticMethodID(cls, "unwrapFloat", "(I)F" ) ;
3405     if (jfloatunwrapFloatjintintID == NULL)
3406     {
3407         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapFloat");
3408     }
3409
3410     jfloat res =  static_cast<jfloat>( curEnv->CallStaticFloatMethod(cls, jfloatunwrapFloatjintintID , x));
3411     curEnv->DeleteLocalRef(cls);
3412     if (curEnv->ExceptionCheck())
3413     {
3414         throw GiwsException::JniCallMethodException(curEnv);
3415     }
3416     return res;
3417
3418 }
3419
3420 float* ScilabJavaObject::unwrapRowFloat (JavaVM * jvm_, int x)
3421 {
3422
3423     JNIEnv * curEnv = NULL;
3424     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3425     jclass cls = curEnv->FindClass( className().c_str() );
3426     if ( cls == NULL)
3427     {
3428         throw GiwsException::JniCallMethodException(curEnv);
3429     }
3430
3431     jmethodID jfloatArray_unwrapRowFloatjintintID = curEnv->GetStaticMethodID(cls, "unwrapRowFloat", "(I)[F" ) ;
3432     if (jfloatArray_unwrapRowFloatjintintID == NULL)
3433     {
3434         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapRowFloat");
3435     }
3436
3437     jfloatArray res =  static_cast<jfloatArray>( curEnv->CallStaticObjectMethod(cls, jfloatArray_unwrapRowFloatjintintID , x));
3438     if (res == NULL)
3439     {
3440         return NULL;
3441     }
3442     if (curEnv->ExceptionCheck())
3443     {
3444         throw GiwsException::JniCallMethodException(curEnv);
3445     }
3446     int lenRow;
3447     lenRow = curEnv->GetArrayLength(res);
3448     jboolean isCopy = JNI_FALSE;
3449
3450     /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
3451     jfloat *resultsArray = static_cast<jfloat *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
3452     float* myArray = new float[ lenRow];
3453
3454     for (jsize i = 0; i <  lenRow; i++)
3455     {
3456         myArray[i] = resultsArray[i];
3457     }
3458     curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
3459
3460     curEnv->DeleteLocalRef(res);
3461     curEnv->DeleteLocalRef(cls);
3462     if (curEnv->ExceptionCheck())
3463     {
3464         delete[] myArray;
3465         throw GiwsException::JniCallMethodException(curEnv);
3466     }
3467     return myArray;
3468
3469 }
3470
3471 float** ScilabJavaObject::unwrapMatFloat (JavaVM * jvm_, int x)
3472 {
3473
3474     JNIEnv * curEnv = NULL;
3475     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3476     jclass cls = curEnv->FindClass( className().c_str() );
3477     if ( cls == NULL)
3478     {
3479         throw GiwsException::JniCallMethodException(curEnv);
3480     }
3481
3482     jmethodID jobjectArray__unwrapMatFloatjintintID = curEnv->GetStaticMethodID(cls, "unwrapMatFloat", "(I)[[F" ) ;
3483     if (jobjectArray__unwrapMatFloatjintintID == NULL)
3484     {
3485         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapMatFloat");
3486     }
3487
3488     jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray__unwrapMatFloatjintintID , x));
3489     if (res == NULL)
3490     {
3491         return NULL;
3492     }
3493     if (curEnv->ExceptionCheck())
3494     {
3495         throw GiwsException::JniCallMethodException(curEnv);
3496     }
3497     int lenCol;
3498     int lenRow;
3499     lenRow = curEnv->GetArrayLength(res);
3500     jboolean isCopy = JNI_FALSE;
3501
3502     float ** myArray = new float*[ lenRow];
3503     for (int i = 0; i < lenRow; i++)
3504     {
3505         jfloatArray oneDim = (jfloatArray)curEnv->GetObjectArrayElement(res, i);
3506         lenCol = curEnv->GetArrayLength(oneDim);
3507         float *resultsArray = static_cast<float *>(curEnv->GetPrimitiveArrayCritical(oneDim, &isCopy));
3508         myArray[i] = new float[ lenCol];
3509         for (int j = 0; j < lenCol; j++)
3510         {
3511             myArray[i][j] = resultsArray[j];
3512         }
3513         curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
3514     }
3515
3516     curEnv->DeleteLocalRef(res);
3517     curEnv->DeleteLocalRef(cls);
3518     if (curEnv->ExceptionCheck())
3519     {
3520         delete[] myArray;
3521         throw GiwsException::JniCallMethodException(curEnv);
3522     }
3523     return myArray;
3524
3525 }
3526
3527 long long ScilabJavaObject::unwrapLong (JavaVM * jvm_, int x)
3528 {
3529
3530     JNIEnv * curEnv = NULL;
3531     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3532     jclass cls = curEnv->FindClass( className().c_str() );
3533     if ( cls == NULL)
3534     {
3535         throw GiwsException::JniCallMethodException(curEnv);
3536     }
3537
3538     jmethodID jlongunwrapLongjintintID = curEnv->GetStaticMethodID(cls, "unwrapLong", "(I)J" ) ;
3539     if (jlongunwrapLongjintintID == NULL)
3540     {
3541         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapLong");
3542     }
3543
3544     jlong res =  static_cast<jlong>( curEnv->CallStaticLongMethod(cls, jlongunwrapLongjintintID , x));
3545     curEnv->DeleteLocalRef(cls);
3546     if (curEnv->ExceptionCheck())
3547     {
3548         throw GiwsException::JniCallMethodException(curEnv);
3549     }
3550     return res;
3551
3552 }
3553
3554 long long* ScilabJavaObject::unwrapRowLong (JavaVM * jvm_, int x)
3555 {
3556
3557     JNIEnv * curEnv = NULL;
3558     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3559     jclass cls = curEnv->FindClass( className().c_str() );
3560     if ( cls == NULL)
3561     {
3562         throw GiwsException::JniCallMethodException(curEnv);
3563     }
3564
3565     jmethodID jlongArray_unwrapRowLongjintintID = curEnv->GetStaticMethodID(cls, "unwrapRowLong", "(I)[J" ) ;
3566     if (jlongArray_unwrapRowLongjintintID == NULL)
3567     {
3568         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapRowLong");
3569     }
3570
3571     jlongArray res =  static_cast<jlongArray>( curEnv->CallStaticObjectMethod(cls, jlongArray_unwrapRowLongjintintID , x));
3572     if (res == NULL)
3573     {
3574         return NULL;
3575     }
3576     if (curEnv->ExceptionCheck())
3577     {
3578         throw GiwsException::JniCallMethodException(curEnv);
3579     }
3580     int lenRow;
3581     lenRow = curEnv->GetArrayLength(res);
3582     jboolean isCopy = JNI_FALSE;
3583
3584     /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
3585     jlong *resultsArray = static_cast<jlong *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
3586     long long* myArray = new long long[ lenRow];
3587
3588     for (jsize i = 0; i <  lenRow; i++)
3589     {
3590         myArray[i] = resultsArray[i];
3591     }
3592     curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
3593
3594     curEnv->DeleteLocalRef(res);
3595     curEnv->DeleteLocalRef(cls);
3596     if (curEnv->ExceptionCheck())
3597     {
3598         delete[] myArray;
3599         throw GiwsException::JniCallMethodException(curEnv);
3600     }
3601     return myArray;
3602
3603 }
3604
3605 long long** ScilabJavaObject::unwrapMatLong (JavaVM * jvm_, int x)
3606 {
3607
3608     JNIEnv * curEnv = NULL;
3609     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3610     jclass cls = curEnv->FindClass( className().c_str() );
3611     if ( cls == NULL)
3612     {
3613         throw GiwsException::JniCallMethodException(curEnv);
3614     }
3615
3616     jmethodID jobjectArray__unwrapMatLongjintintID = curEnv->GetStaticMethodID(cls, "unwrapMatLong", "(I)[[J" ) ;
3617     if (jobjectArray__unwrapMatLongjintintID == NULL)
3618     {
3619         throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapMatLong");
3620     }
3621
3622     jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray__unwrapMatLongjintintID , x));
3623     if (res == NULL)
3624     {
3625         return NULL;
3626     }
3627     if (curEnv->ExceptionCheck())
3628     {
3629         throw GiwsException::JniCallMethodException(curEnv);
3630     }
3631     int lenCol;
3632     int lenRow;
3633     lenRow = curEnv->GetArrayLength(res);
3634     jboolean isCopy = JNI_FALSE;
3635
3636     long long ** myArray = new long long*[ lenRow];
3637     for (int i = 0; i < lenRow; i++)
3638     {
3639         jlongArray oneDim = (jlongArray)curEnv->GetObjectArrayElement(res, i);
3640         lenCol = curEnv->GetArrayLength(oneDim);
3641         long long *resultsArray = static_cast<long long *>(curEnv->GetPrimitiveArrayCritical(oneDim, &isCopy));
3642         myArray[i] = new long long[ lenCol];
3643         for (int j = 0; j < lenCol; j++)
3644         {
3645             myArray[i][j] = resultsArray[j];
3646         }
3647         curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
3648     }
3649
3650     curEnv->DeleteLocalRef(res);
3651     curEnv->DeleteLocalRef(cls);
3652     if (curEnv->ExceptionCheck())
3653     {
3654         delete[] myArray;
3655         throw GiwsException::JniCallMethodException(curEnv);
3656     }
3657     return myArray;
3658
3659 }
3660
3661 }