Update giws files with version 2.0.2 to improve performances:
[scilab.git] / scilab / modules / graphic_objects / src / jni / CallGraphicController.cpp
1 #include "CallGraphicController.hxx"
2 /* Generated by GIWS (version 2.0.2) with command:
3 giws --disable-return-size-array --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/graphic_objects.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_graphic_objects
40 {
41
42 // Static declarations (if any)
43
44 // Returns the current env
45
46 JNIEnv * CallGraphicController::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 CallGraphicController::~CallGraphicController()
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 CallGraphicController::CallGraphicController(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     voiddeleteGraphicObjectjintintID = NULL;
118     jintcloneGraphicObjectjintintID = NULL;
119     jintaskGraphicObjectjintintID = NULL;
120     voidsetGraphicObjectRelationshipjintintjintintID = NULL;
121     voidremoveRelationShipAndDeletejintintID = NULL;
122     jstringgetGraphicObjectPropertyAsStringjintintjintintID = NULL;
123     jbooleansetGraphicObjectPropertyjintintjintintjstringjava_lang_StringID = NULL;
124     jobjectArray_getGraphicObjectPropertyAsStringVectorjintintjintintID = NULL;
125     jbooleansetGraphicObjectPropertyjintintjintintjobjectArray_java_lang_Stringjava_lang_StringID = NULL;
126     jbooleansetGraphicObjectPropertyjintintjintintjdoubledoubleID = NULL;
127     jdoubleArray_getGraphicObjectPropertyAsDoubleVectorjintintjintintID = NULL;
128     jbooleansetGraphicObjectPropertyjintintjintintjdoubleArray_doubledoubleID = NULL;
129     jbooleansetGraphicObjectPropertyjintintjintintjintintID = NULL;
130     jintArray_getGraphicObjectPropertyAsIntegerVectorjintintjintintID = NULL;
131     jbooleansetGraphicObjectPropertyjintintjintintjintArray_intintID = NULL;
132     jbooleansetGraphicObjectPropertyjintintjintintjbooleanbooleanID = NULL;
133     jintArray_getGraphicObjectPropertyAsBooleanVectorjintintjintintID = NULL;
134     jbooleansetGraphicObjectPropertyjintintjintintjbooleanArray_booleanbooleanID = NULL;
135     voidregisterScilabViewID = NULL;
136     voidunregisterScilabViewID = NULL;
137     jintgetConsoleIdentifierID = NULL;
138     voidbuildFigureMenuBarjintintID = NULL;
139
140
141 }
142
143 CallGraphicController::CallGraphicController(JavaVM * jvm_, jobject JObj)
144 {
145     jvm = jvm_;
146
147     JNIEnv * curEnv = getCurrentEnv();
148
149     jclass localClass = curEnv->GetObjectClass(JObj);
150     this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
151     curEnv->DeleteLocalRef(localClass);
152
153     if (this->instanceClass == NULL)
154     {
155         throw GiwsException::JniObjectCreationException(curEnv, this->className());
156     }
157
158     this->instance = curEnv->NewGlobalRef(JObj) ;
159     if (this->instance == NULL)
160     {
161         throw GiwsException::JniObjectCreationException(curEnv, this->className());
162     }
163     /* Methods ID set to NULL */
164     voiddeleteGraphicObjectjintintID = NULL;
165     jintcloneGraphicObjectjintintID = NULL;
166     jintaskGraphicObjectjintintID = NULL;
167     voidsetGraphicObjectRelationshipjintintjintintID = NULL;
168     voidremoveRelationShipAndDeletejintintID = NULL;
169     jstringgetGraphicObjectPropertyAsStringjintintjintintID = NULL;
170     jbooleansetGraphicObjectPropertyjintintjintintjstringjava_lang_StringID = NULL;
171     jobjectArray_getGraphicObjectPropertyAsStringVectorjintintjintintID = NULL;
172     jbooleansetGraphicObjectPropertyjintintjintintjobjectArray_java_lang_Stringjava_lang_StringID = NULL;
173     jbooleansetGraphicObjectPropertyjintintjintintjdoubledoubleID = NULL;
174     jdoubleArray_getGraphicObjectPropertyAsDoubleVectorjintintjintintID = NULL;
175     jbooleansetGraphicObjectPropertyjintintjintintjdoubleArray_doubledoubleID = NULL;
176     jbooleansetGraphicObjectPropertyjintintjintintjintintID = NULL;
177     jintArray_getGraphicObjectPropertyAsIntegerVectorjintintjintintID = NULL;
178     jbooleansetGraphicObjectPropertyjintintjintintjintArray_intintID = NULL;
179     jbooleansetGraphicObjectPropertyjintintjintintjbooleanbooleanID = NULL;
180     jintArray_getGraphicObjectPropertyAsBooleanVectorjintintjintintID = NULL;
181     jbooleansetGraphicObjectPropertyjintintjintintjbooleanArray_booleanbooleanID = NULL;
182     voidregisterScilabViewID = NULL;
183     voidunregisterScilabViewID = NULL;
184     jintgetConsoleIdentifierID = NULL;
185     voidbuildFigureMenuBarjintintID = NULL;
186
187
188 }
189
190 // Generic methods
191
192 void CallGraphicController::synchronize()
193 {
194     if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK)
195     {
196         throw GiwsException::JniMonitorException(getCurrentEnv(), "CallGraphicController");
197     }
198 }
199
200 void CallGraphicController::endSynchronize()
201 {
202     if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK)
203     {
204         throw GiwsException::JniMonitorException(getCurrentEnv(), "CallGraphicController");
205     }
206 }
207 // Method(s)
208
209 void CallGraphicController::deleteGraphicObject (JavaVM * jvm_, int id)
210 {
211
212     JNIEnv * curEnv = NULL;
213     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
214     jclass cls = initClass(curEnv);
215     if ( cls == NULL)
216     {
217         throw GiwsException::JniCallMethodException(curEnv);
218     }
219
220     static jmethodID voiddeleteGraphicObjectjintintID = curEnv->GetStaticMethodID(cls, "deleteGraphicObject", "(I)V" ) ;
221     if (voiddeleteGraphicObjectjintintID == NULL)
222     {
223         throw GiwsException::JniMethodNotFoundException(curEnv, "deleteGraphicObject");
224     }
225
226     curEnv->CallStaticVoidMethod(cls, voiddeleteGraphicObjectjintintID , id);
227     if (curEnv->ExceptionCheck())
228     {
229         throw GiwsException::JniCallMethodException(curEnv);
230     }
231 }
232
233 int CallGraphicController::cloneGraphicObject (JavaVM * jvm_, int id)
234 {
235
236     JNIEnv * curEnv = NULL;
237     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
238     jclass cls = initClass(curEnv);
239     if ( cls == NULL)
240     {
241         throw GiwsException::JniCallMethodException(curEnv);
242     }
243
244     static jmethodID jintcloneGraphicObjectjintintID = curEnv->GetStaticMethodID(cls, "cloneGraphicObject", "(I)I" ) ;
245     if (jintcloneGraphicObjectjintintID == NULL)
246     {
247         throw GiwsException::JniMethodNotFoundException(curEnv, "cloneGraphicObject");
248     }
249
250     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcloneGraphicObjectjintintID , id));
251     if (curEnv->ExceptionCheck())
252     {
253         throw GiwsException::JniCallMethodException(curEnv);
254     }
255     return res;
256
257 }
258
259 int CallGraphicController::askGraphicObject (JavaVM * jvm_, int typeName)
260 {
261
262     JNIEnv * curEnv = NULL;
263     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
264     jclass cls = initClass(curEnv);
265     if ( cls == NULL)
266     {
267         throw GiwsException::JniCallMethodException(curEnv);
268     }
269
270     static jmethodID jintaskGraphicObjectjintintID = curEnv->GetStaticMethodID(cls, "askGraphicObject", "(I)I" ) ;
271     if (jintaskGraphicObjectjintintID == NULL)
272     {
273         throw GiwsException::JniMethodNotFoundException(curEnv, "askGraphicObject");
274     }
275
276     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintaskGraphicObjectjintintID , typeName));
277     if (curEnv->ExceptionCheck())
278     {
279         throw GiwsException::JniCallMethodException(curEnv);
280     }
281     return res;
282
283 }
284
285 void CallGraphicController::setGraphicObjectRelationship (JavaVM * jvm_, int parentId, int childId)
286 {
287
288     JNIEnv * curEnv = NULL;
289     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
290     jclass cls = initClass(curEnv);
291     if ( cls == NULL)
292     {
293         throw GiwsException::JniCallMethodException(curEnv);
294     }
295
296     static jmethodID voidsetGraphicObjectRelationshipjintintjintintID = curEnv->GetStaticMethodID(cls, "setGraphicObjectRelationship", "(II)V" ) ;
297     if (voidsetGraphicObjectRelationshipjintintjintintID == NULL)
298     {
299         throw GiwsException::JniMethodNotFoundException(curEnv, "setGraphicObjectRelationship");
300     }
301
302     curEnv->CallStaticVoidMethod(cls, voidsetGraphicObjectRelationshipjintintjintintID , parentId, childId);
303     if (curEnv->ExceptionCheck())
304     {
305         throw GiwsException::JniCallMethodException(curEnv);
306     }
307 }
308
309 void CallGraphicController::removeRelationShipAndDelete (JavaVM * jvm_, int id)
310 {
311
312     JNIEnv * curEnv = NULL;
313     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
314     jclass cls = initClass(curEnv);
315     if ( cls == NULL)
316     {
317         throw GiwsException::JniCallMethodException(curEnv);
318     }
319
320     static jmethodID voidremoveRelationShipAndDeletejintintID = curEnv->GetStaticMethodID(cls, "removeRelationShipAndDelete", "(I)V" ) ;
321     if (voidremoveRelationShipAndDeletejintintID == NULL)
322     {
323         throw GiwsException::JniMethodNotFoundException(curEnv, "removeRelationShipAndDelete");
324     }
325
326     curEnv->CallStaticVoidMethod(cls, voidremoveRelationShipAndDeletejintintID , id);
327     if (curEnv->ExceptionCheck())
328     {
329         throw GiwsException::JniCallMethodException(curEnv);
330     }
331 }
332
333 char* CallGraphicController::getGraphicObjectPropertyAsString (JavaVM * jvm_, int id, int propertyName)
334 {
335
336     JNIEnv * curEnv = NULL;
337     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
338     jclass cls = initClass(curEnv);
339     if ( cls == NULL)
340     {
341         throw GiwsException::JniCallMethodException(curEnv);
342     }
343
344     static jmethodID jstringgetGraphicObjectPropertyAsStringjintintjintintID = curEnv->GetStaticMethodID(cls, "getGraphicObjectPropertyAsString", "(II)Ljava/lang/String;" ) ;
345     if (jstringgetGraphicObjectPropertyAsStringjintintjintintID == NULL)
346     {
347         throw GiwsException::JniMethodNotFoundException(curEnv, "getGraphicObjectPropertyAsString");
348     }
349
350     jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringgetGraphicObjectPropertyAsStringjintintjintintID , id, propertyName));
351     if (curEnv->ExceptionCheck())
352     {
353         throw GiwsException::JniCallMethodException(curEnv);
354     }
355     if (res != NULL)
356     {
357
358         const char *tempString = curEnv->GetStringUTFChars(res, 0);
359         char * myStringBuffer = new char[strlen(tempString) + 1];
360         strcpy(myStringBuffer, tempString);
361         curEnv->ReleaseStringUTFChars(res, tempString);
362         curEnv->DeleteLocalRef(res);
363         if (curEnv->ExceptionCheck())
364         {
365             delete[] myStringBuffer;
366             throw GiwsException::JniCallMethodException(curEnv);
367         }
368         return myStringBuffer;
369     }
370     else
371     {
372         curEnv->DeleteLocalRef(res);
373         return NULL;
374     }
375 }
376
377 bool CallGraphicController::setGraphicObjectProperty (JavaVM * jvm_, int id, int propertyName, char const* value)
378 {
379
380     JNIEnv * curEnv = NULL;
381     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
382     jclass cls = initClass(curEnv);
383     if ( cls == NULL)
384     {
385         throw GiwsException::JniCallMethodException(curEnv);
386     }
387
388     static jmethodID jbooleansetGraphicObjectPropertyjintintjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setGraphicObjectProperty", "(IILjava/lang/String;)Z" ) ;
389     if (jbooleansetGraphicObjectPropertyjintintjintintjstringjava_lang_StringID == NULL)
390     {
391         throw GiwsException::JniMethodNotFoundException(curEnv, "setGraphicObjectProperty");
392     }
393
394     jstring value_ = curEnv->NewStringUTF( value );
395     if (value != NULL && value_ == NULL)
396     {
397         throw GiwsException::JniBadAllocException(curEnv);
398     }
399
400
401     jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleansetGraphicObjectPropertyjintintjintintjstringjava_lang_StringID , id, propertyName, value_));
402     curEnv->DeleteLocalRef(value_);
403     if (curEnv->ExceptionCheck())
404     {
405         throw GiwsException::JniCallMethodException(curEnv);
406     }
407     return (res == JNI_TRUE);
408
409 }
410
411 char** CallGraphicController::getGraphicObjectPropertyAsStringVector (JavaVM * jvm_, int id, int propertyName)
412 {
413
414     JNIEnv * curEnv = NULL;
415     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
416     jclass cls = initClass(curEnv);
417     if ( cls == NULL)
418     {
419         throw GiwsException::JniCallMethodException(curEnv);
420     }
421
422     static jmethodID jobjectArray_getGraphicObjectPropertyAsStringVectorjintintjintintID = curEnv->GetStaticMethodID(cls, "getGraphicObjectPropertyAsStringVector", "(II)[Ljava/lang/String;" ) ;
423     if (jobjectArray_getGraphicObjectPropertyAsStringVectorjintintjintintID == NULL)
424     {
425         throw GiwsException::JniMethodNotFoundException(curEnv, "getGraphicObjectPropertyAsStringVector");
426     }
427
428     jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray_getGraphicObjectPropertyAsStringVectorjintintjintintID , id, propertyName));
429     if (curEnv->ExceptionCheck())
430     {
431         throw GiwsException::JniCallMethodException(curEnv);
432     }
433     if (res != NULL)
434     {
435         int lenRow;
436         lenRow = curEnv->GetArrayLength(res);
437
438         char **arrayOfString;
439         arrayOfString = new char *[lenRow];
440         for (jsize i = 0; i < lenRow; i++)
441         {
442             jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
443             const char *tempString = curEnv->GetStringUTFChars(resString, 0);
444             arrayOfString[i] = new char[strlen(tempString) + 1];
445
446             strcpy(arrayOfString[i], tempString);
447             curEnv->ReleaseStringUTFChars(resString, tempString);
448             curEnv->DeleteLocalRef(resString);
449         }
450         if (curEnv->ExceptionCheck())
451         {
452             delete[] arrayOfString;
453             throw GiwsException::JniCallMethodException(curEnv);
454         }
455         curEnv->DeleteLocalRef(res);
456         return arrayOfString;
457     }
458     else
459     {
460         curEnv->DeleteLocalRef(res);
461         return NULL;
462     }
463 }
464
465 bool CallGraphicController::setGraphicObjectProperty (JavaVM * jvm_, int id, int propertyName, char const* const* value, int valueSize)
466 {
467
468     JNIEnv * curEnv = NULL;
469     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
470     jclass cls = initClass(curEnv);
471     if ( cls == NULL)
472     {
473         throw GiwsException::JniCallMethodException(curEnv);
474     }
475
476     static jmethodID jbooleansetGraphicObjectPropertyjintintjintintjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setGraphicObjectProperty", "(II[Ljava/lang/String;)Z" ) ;
477     if (jbooleansetGraphicObjectPropertyjintintjintintjobjectArray_java_lang_Stringjava_lang_StringID == NULL)
478     {
479         throw GiwsException::JniMethodNotFoundException(curEnv, "setGraphicObjectProperty");
480     }
481     jclass stringArrayClass = curEnv->FindClass("java/lang/String");
482
483     // create java array of strings.
484     jobjectArray value_ = curEnv->NewObjectArray( valueSize, stringArrayClass, NULL);
485     if (value_ == NULL)
486     {
487         throw GiwsException::JniBadAllocException(curEnv);
488     }
489
490     // convert each char * to java strings and fill the java array.
491     for ( int i = 0; i < valueSize; i++)
492     {
493         jstring TempString = curEnv->NewStringUTF( value[i] );
494         if (TempString == NULL)
495         {
496             throw GiwsException::JniBadAllocException(curEnv);
497         }
498
499         curEnv->SetObjectArrayElement( value_, i, TempString);
500
501         // avoid keeping reference on too many strings
502         curEnv->DeleteLocalRef(TempString);
503     }
504     jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleansetGraphicObjectPropertyjintintjintintjobjectArray_java_lang_Stringjava_lang_StringID , id, propertyName, value_));
505     curEnv->DeleteLocalRef(stringArrayClass);
506     curEnv->DeleteLocalRef(value_);
507     if (curEnv->ExceptionCheck())
508     {
509         throw GiwsException::JniCallMethodException(curEnv);
510     }
511     return (res == JNI_TRUE);
512
513 }
514
515 bool CallGraphicController::setGraphicObjectProperty (JavaVM * jvm_, int id, int propertyName, double value)
516 {
517
518     JNIEnv * curEnv = NULL;
519     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
520     jclass cls = initClass(curEnv);
521     if ( cls == NULL)
522     {
523         throw GiwsException::JniCallMethodException(curEnv);
524     }
525
526     static jmethodID jbooleansetGraphicObjectPropertyjintintjintintjdoubledoubleID = curEnv->GetStaticMethodID(cls, "setGraphicObjectProperty", "(IID)Z" ) ;
527     if (jbooleansetGraphicObjectPropertyjintintjintintjdoubledoubleID == NULL)
528     {
529         throw GiwsException::JniMethodNotFoundException(curEnv, "setGraphicObjectProperty");
530     }
531
532     jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleansetGraphicObjectPropertyjintintjintintjdoubledoubleID , id, propertyName, value));
533     if (curEnv->ExceptionCheck())
534     {
535         throw GiwsException::JniCallMethodException(curEnv);
536     }
537     return (res == JNI_TRUE);
538
539 }
540
541 double* CallGraphicController::getGraphicObjectPropertyAsDoubleVector (JavaVM * jvm_, int id, int propertyName)
542 {
543
544     JNIEnv * curEnv = NULL;
545     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
546     jclass cls = initClass(curEnv);
547     if ( cls == NULL)
548     {
549         throw GiwsException::JniCallMethodException(curEnv);
550     }
551
552     static jmethodID jdoubleArray_getGraphicObjectPropertyAsDoubleVectorjintintjintintID = curEnv->GetStaticMethodID(cls, "getGraphicObjectPropertyAsDoubleVector", "(II)[D" ) ;
553     if (jdoubleArray_getGraphicObjectPropertyAsDoubleVectorjintintjintintID == NULL)
554     {
555         throw GiwsException::JniMethodNotFoundException(curEnv, "getGraphicObjectPropertyAsDoubleVector");
556     }
557
558     jdoubleArray res =  static_cast<jdoubleArray>( curEnv->CallStaticObjectMethod(cls, jdoubleArray_getGraphicObjectPropertyAsDoubleVectorjintintjintintID , id, propertyName));
559     if (res == NULL)
560     {
561         return NULL;
562     }
563     if (curEnv->ExceptionCheck())
564     {
565         throw GiwsException::JniCallMethodException(curEnv);
566     }
567     int lenRow;
568     lenRow = curEnv->GetArrayLength(res);
569     jboolean isCopy = JNI_FALSE;
570
571     /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
572     jdouble *resultsArray = static_cast<jdouble *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
573     double* myArray = new double[ lenRow];
574
575     for (jsize i = 0; i <  lenRow; i++)
576     {
577         myArray[i] = resultsArray[i];
578     }
579     curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
580
581     curEnv->DeleteLocalRef(res);
582     if (curEnv->ExceptionCheck())
583     {
584         delete[] myArray;
585         throw GiwsException::JniCallMethodException(curEnv);
586     }
587     return myArray;
588
589 }
590
591 bool CallGraphicController::setGraphicObjectProperty (JavaVM * jvm_, int id, int propertyName, double const* value, int valueSize)
592 {
593
594     JNIEnv * curEnv = NULL;
595     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
596     jclass cls = initClass(curEnv);
597     if ( cls == NULL)
598     {
599         throw GiwsException::JniCallMethodException(curEnv);
600     }
601
602     static jmethodID jbooleansetGraphicObjectPropertyjintintjintintjdoubleArray_doubledoubleID = curEnv->GetStaticMethodID(cls, "setGraphicObjectProperty", "(II[D)Z" ) ;
603     if (jbooleansetGraphicObjectPropertyjintintjintintjdoubleArray_doubledoubleID == NULL)
604     {
605         throw GiwsException::JniMethodNotFoundException(curEnv, "setGraphicObjectProperty");
606     }
607
608     jdoubleArray value_ = curEnv->NewDoubleArray( valueSize ) ;
609
610     if (value_ == NULL)
611     {
612         // check that allocation succeed
613         throw GiwsException::JniBadAllocException(curEnv);
614     }
615
616     curEnv->SetDoubleArrayRegion( value_, 0, valueSize, (jdouble*)(value) ) ;
617
618
619     jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleansetGraphicObjectPropertyjintintjintintjdoubleArray_doubledoubleID , id, propertyName, value_));
620     curEnv->DeleteLocalRef(value_);
621     if (curEnv->ExceptionCheck())
622     {
623         throw GiwsException::JniCallMethodException(curEnv);
624     }
625     return (res == JNI_TRUE);
626
627 }
628
629 bool CallGraphicController::setGraphicObjectProperty (JavaVM * jvm_, int id, int propertyName, int value)
630 {
631
632     JNIEnv * curEnv = NULL;
633     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
634     jclass cls = initClass(curEnv);
635     if ( cls == NULL)
636     {
637         throw GiwsException::JniCallMethodException(curEnv);
638     }
639
640     static jmethodID jbooleansetGraphicObjectPropertyjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "setGraphicObjectProperty", "(III)Z" ) ;
641     if (jbooleansetGraphicObjectPropertyjintintjintintjintintID == NULL)
642     {
643         throw GiwsException::JniMethodNotFoundException(curEnv, "setGraphicObjectProperty");
644     }
645
646     jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleansetGraphicObjectPropertyjintintjintintjintintID , id, propertyName, value));
647     if (curEnv->ExceptionCheck())
648     {
649         throw GiwsException::JniCallMethodException(curEnv);
650     }
651     return (res == JNI_TRUE);
652
653 }
654
655 int* CallGraphicController::getGraphicObjectPropertyAsIntegerVector (JavaVM * jvm_, int id, int propertyName)
656 {
657
658     JNIEnv * curEnv = NULL;
659     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
660     jclass cls = initClass(curEnv);
661     if ( cls == NULL)
662     {
663         throw GiwsException::JniCallMethodException(curEnv);
664     }
665
666     static jmethodID jintArray_getGraphicObjectPropertyAsIntegerVectorjintintjintintID = curEnv->GetStaticMethodID(cls, "getGraphicObjectPropertyAsIntegerVector", "(II)[I" ) ;
667     if (jintArray_getGraphicObjectPropertyAsIntegerVectorjintintjintintID == NULL)
668     {
669         throw GiwsException::JniMethodNotFoundException(curEnv, "getGraphicObjectPropertyAsIntegerVector");
670     }
671
672     jintArray res =  static_cast<jintArray>( curEnv->CallStaticObjectMethod(cls, jintArray_getGraphicObjectPropertyAsIntegerVectorjintintjintintID , id, propertyName));
673     if (res == NULL)
674     {
675         return NULL;
676     }
677     if (curEnv->ExceptionCheck())
678     {
679         throw GiwsException::JniCallMethodException(curEnv);
680     }
681     int lenRow;
682     lenRow = curEnv->GetArrayLength(res);
683     jboolean isCopy = JNI_FALSE;
684
685     /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
686     jint *resultsArray = static_cast<jint *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
687     int* myArray = new int[ lenRow];
688
689     for (jsize i = 0; i <  lenRow; i++)
690     {
691         myArray[i] = resultsArray[i];
692     }
693     curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
694
695     curEnv->DeleteLocalRef(res);
696     if (curEnv->ExceptionCheck())
697     {
698         delete[] myArray;
699         throw GiwsException::JniCallMethodException(curEnv);
700     }
701     return myArray;
702
703 }
704
705 bool CallGraphicController::setGraphicObjectProperty (JavaVM * jvm_, int id, int propertyName, int const* value, int valueSize)
706 {
707
708     JNIEnv * curEnv = NULL;
709     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
710     jclass cls = initClass(curEnv);
711     if ( cls == NULL)
712     {
713         throw GiwsException::JniCallMethodException(curEnv);
714     }
715
716     static jmethodID jbooleansetGraphicObjectPropertyjintintjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "setGraphicObjectProperty", "(II[I)Z" ) ;
717     if (jbooleansetGraphicObjectPropertyjintintjintintjintArray_intintID == NULL)
718     {
719         throw GiwsException::JniMethodNotFoundException(curEnv, "setGraphicObjectProperty");
720     }
721
722     jintArray value_ = curEnv->NewIntArray( valueSize ) ;
723
724     if (value_ == NULL)
725     {
726         // check that allocation succeed
727         throw GiwsException::JniBadAllocException(curEnv);
728     }
729
730     curEnv->SetIntArrayRegion( value_, 0, valueSize, (jint*)(value) ) ;
731
732
733     jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleansetGraphicObjectPropertyjintintjintintjintArray_intintID , id, propertyName, value_));
734     curEnv->DeleteLocalRef(value_);
735     if (curEnv->ExceptionCheck())
736     {
737         throw GiwsException::JniCallMethodException(curEnv);
738     }
739     return (res == JNI_TRUE);
740
741 }
742
743 bool CallGraphicController::setGraphicObjectProperty (JavaVM * jvm_, int id, int propertyName, bool value)
744 {
745
746     JNIEnv * curEnv = NULL;
747     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
748     jclass cls = initClass(curEnv);
749     if ( cls == NULL)
750     {
751         throw GiwsException::JniCallMethodException(curEnv);
752     }
753
754     static jmethodID jbooleansetGraphicObjectPropertyjintintjintintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "setGraphicObjectProperty", "(IIZ)Z" ) ;
755     if (jbooleansetGraphicObjectPropertyjintintjintintjbooleanbooleanID == NULL)
756     {
757         throw GiwsException::JniMethodNotFoundException(curEnv, "setGraphicObjectProperty");
758     }
759
760     jboolean value_ = (static_cast<bool>(value) ? JNI_TRUE : JNI_FALSE);
761
762     jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleansetGraphicObjectPropertyjintintjintintjbooleanbooleanID , id, propertyName, value_));
763     if (curEnv->ExceptionCheck())
764     {
765         throw GiwsException::JniCallMethodException(curEnv);
766     }
767     return (res == JNI_TRUE);
768
769 }
770
771 int* CallGraphicController::getGraphicObjectPropertyAsBooleanVector (JavaVM * jvm_, int id, int propertyName)
772 {
773
774     JNIEnv * curEnv = NULL;
775     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
776     jclass cls = initClass(curEnv);
777     if ( cls == NULL)
778     {
779         throw GiwsException::JniCallMethodException(curEnv);
780     }
781
782     static jmethodID jintArray_getGraphicObjectPropertyAsBooleanVectorjintintjintintID = curEnv->GetStaticMethodID(cls, "getGraphicObjectPropertyAsBooleanVector", "(II)[I" ) ;
783     if (jintArray_getGraphicObjectPropertyAsBooleanVectorjintintjintintID == NULL)
784     {
785         throw GiwsException::JniMethodNotFoundException(curEnv, "getGraphicObjectPropertyAsBooleanVector");
786     }
787
788     jintArray res =  static_cast<jintArray>( curEnv->CallStaticObjectMethod(cls, jintArray_getGraphicObjectPropertyAsBooleanVectorjintintjintintID , id, propertyName));
789     if (res == NULL)
790     {
791         return NULL;
792     }
793     if (curEnv->ExceptionCheck())
794     {
795         throw GiwsException::JniCallMethodException(curEnv);
796     }
797     int lenRow;
798     lenRow = curEnv->GetArrayLength(res);
799     jboolean isCopy = JNI_FALSE;
800
801     /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
802     jint *resultsArray = static_cast<jint *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
803     int* myArray = new int[ lenRow];
804
805     for (jsize i = 0; i <  lenRow; i++)
806     {
807         myArray[i] = resultsArray[i];
808     }
809     curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
810
811     curEnv->DeleteLocalRef(res);
812     if (curEnv->ExceptionCheck())
813     {
814         delete[] myArray;
815         throw GiwsException::JniCallMethodException(curEnv);
816     }
817     return myArray;
818
819 }
820
821 bool CallGraphicController::setGraphicObjectProperty (JavaVM * jvm_, int id, int propertyName, bool const* value, int valueSize)
822 {
823
824     JNIEnv * curEnv = NULL;
825     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
826     jclass cls = initClass(curEnv);
827     if ( cls == NULL)
828     {
829         throw GiwsException::JniCallMethodException(curEnv);
830     }
831
832     static jmethodID jbooleansetGraphicObjectPropertyjintintjintintjbooleanArray_booleanbooleanID = curEnv->GetStaticMethodID(cls, "setGraphicObjectProperty", "(II[Z)Z" ) ;
833     if (jbooleansetGraphicObjectPropertyjintintjintintjbooleanArray_booleanbooleanID == NULL)
834     {
835         throw GiwsException::JniMethodNotFoundException(curEnv, "setGraphicObjectProperty");
836     }
837
838     jbooleanArray value_ = curEnv->NewBooleanArray( valueSize ) ;
839     curEnv->SetBooleanArrayRegion( value_, 0, valueSize, (jboolean*)value ) ;
840
841     jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleansetGraphicObjectPropertyjintintjintintjbooleanArray_booleanbooleanID , id, propertyName, value_));
842     curEnv->DeleteLocalRef(value_);
843     if (curEnv->ExceptionCheck())
844     {
845         throw GiwsException::JniCallMethodException(curEnv);
846     }
847     return (res == JNI_TRUE);
848
849 }
850
851 void CallGraphicController::registerScilabView (JavaVM * jvm_)
852 {
853
854     JNIEnv * curEnv = NULL;
855     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
856     jclass cls = initClass(curEnv);
857     if ( cls == NULL)
858     {
859         throw GiwsException::JniCallMethodException(curEnv);
860     }
861
862     static jmethodID voidregisterScilabViewID = curEnv->GetStaticMethodID(cls, "registerScilabView", "()V" ) ;
863     if (voidregisterScilabViewID == NULL)
864     {
865         throw GiwsException::JniMethodNotFoundException(curEnv, "registerScilabView");
866     }
867
868     curEnv->CallStaticVoidMethod(cls, voidregisterScilabViewID );
869     if (curEnv->ExceptionCheck())
870     {
871         throw GiwsException::JniCallMethodException(curEnv);
872     }
873 }
874
875 void CallGraphicController::unregisterScilabView (JavaVM * jvm_)
876 {
877
878     JNIEnv * curEnv = NULL;
879     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
880     jclass cls = initClass(curEnv);
881     if ( cls == NULL)
882     {
883         throw GiwsException::JniCallMethodException(curEnv);
884     }
885
886     static jmethodID voidunregisterScilabViewID = curEnv->GetStaticMethodID(cls, "unregisterScilabView", "()V" ) ;
887     if (voidunregisterScilabViewID == NULL)
888     {
889         throw GiwsException::JniMethodNotFoundException(curEnv, "unregisterScilabView");
890     }
891
892     curEnv->CallStaticVoidMethod(cls, voidunregisterScilabViewID );
893     if (curEnv->ExceptionCheck())
894     {
895         throw GiwsException::JniCallMethodException(curEnv);
896     }
897 }
898
899 int CallGraphicController::getConsoleIdentifier (JavaVM * jvm_)
900 {
901
902     JNIEnv * curEnv = NULL;
903     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
904     jclass cls = initClass(curEnv);
905     if ( cls == NULL)
906     {
907         throw GiwsException::JniCallMethodException(curEnv);
908     }
909
910     static jmethodID jintgetConsoleIdentifierID = curEnv->GetStaticMethodID(cls, "getConsoleIdentifier", "()I" ) ;
911     if (jintgetConsoleIdentifierID == NULL)
912     {
913         throw GiwsException::JniMethodNotFoundException(curEnv, "getConsoleIdentifier");
914     }
915
916     jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetConsoleIdentifierID ));
917     if (curEnv->ExceptionCheck())
918     {
919         throw GiwsException::JniCallMethodException(curEnv);
920     }
921     return res;
922
923 }
924
925 void CallGraphicController::buildFigureMenuBar (JavaVM * jvm_, int figureId)
926 {
927
928     JNIEnv * curEnv = NULL;
929     jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
930     jclass cls = initClass(curEnv);
931     if ( cls == NULL)
932     {
933         throw GiwsException::JniCallMethodException(curEnv);
934     }
935
936     static jmethodID voidbuildFigureMenuBarjintintID = curEnv->GetStaticMethodID(cls, "buildFigureMenuBar", "(I)V" ) ;
937     if (voidbuildFigureMenuBarjintintID == NULL)
938     {
939         throw GiwsException::JniMethodNotFoundException(curEnv, "buildFigureMenuBar");
940     }
941
942     curEnv->CallStaticVoidMethod(cls, voidbuildFigureMenuBarjintintID , figureId);
943     if (curEnv->ExceptionCheck())
944     {
945         throw GiwsException::JniCallMethodException(curEnv);
946     }
947 }
948
949 }