646598580f16d77d9949f3afc0515c471943fcac
[scilab.git] / scilab / modules / graphic_objects / src / jni / CallGraphicController.cpp
1 #include "CallGraphicController.hxx"
2 /* Generated by GIWS (version 2.0.1) with command:
3 giws --disable-return-size-array --output-dir D:\git\debug\master\scilab\modules\graphic_objects\src\jni\ --throws-exception-on-error --description-file 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                 // Static declarations (if any)
42                 
43 // Returns the current env
44
45 JNIEnv * CallGraphicController::getCurrentEnv() {
46 JNIEnv * curEnv = NULL;
47 jint res=this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
48 if (res != JNI_OK) {
49 throw GiwsException::JniException(getCurrentEnv());
50 }
51 return curEnv;
52 }
53 // Destructor
54
55 CallGraphicController::~CallGraphicController() {
56 JNIEnv * curEnv = NULL;
57 this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
58
59 curEnv->DeleteGlobalRef(this->instance);
60 curEnv->DeleteGlobalRef(this->instanceClass);
61 curEnv->DeleteGlobalRef(this->stringArrayClass);}
62 // Constructors
63 CallGraphicController::CallGraphicController(JavaVM * jvm_) {
64 jmethodID constructObject = NULL ;
65 jobject localInstance ;
66 jclass localClass ;
67
68 const std::string construct="<init>";
69 const std::string param="()V";
70 jvm=jvm_;
71
72 JNIEnv * curEnv = getCurrentEnv();
73
74 localClass = curEnv->FindClass( this->className().c_str() ) ;
75 if (localClass == NULL) {
76   throw GiwsException::JniClassNotFoundException(curEnv, this->className());
77 }
78
79 this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
80
81 /* localClass is not needed anymore */
82 curEnv->DeleteLocalRef(localClass);
83
84 if (this->instanceClass == NULL) {
85 throw GiwsException::JniObjectCreationException(curEnv, this->className());
86 }
87
88
89 constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
90 if(constructObject == NULL){
91 throw GiwsException::JniObjectCreationException(curEnv, this->className());
92 }
93
94 localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
95 if(localInstance == NULL){
96 throw GiwsException::JniObjectCreationException(curEnv, this->className());
97 }
98  
99 this->instance = curEnv->NewGlobalRef(localInstance) ;
100 if(this->instance == NULL){
101 throw GiwsException::JniObjectCreationException(curEnv, this->className());
102 }
103 /* localInstance not needed anymore */
104 curEnv->DeleteLocalRef(localInstance);
105
106                 /* Methods ID set to NULL */
107 voiddeleteGraphicObjectjintintID=NULL;
108 jintcloneGraphicObjectjintintID=NULL;
109 jintaskGraphicObjectjintintID=NULL;
110 voidsetGraphicObjectRelationshipjintintjintintID=NULL;
111 voidremoveRelationShipAndDeletejintintID=NULL;
112 jstringgetGraphicObjectPropertyAsStringjintintjintintID=NULL;
113 jbooleansetGraphicObjectPropertyjintintjintintjstringjava_lang_StringID=NULL;
114 jobjectArray_getGraphicObjectPropertyAsStringVectorjintintjintintID=NULL;
115 jbooleansetGraphicObjectPropertyjintintjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
116 jbooleansetGraphicObjectPropertyjintintjintintjdoubledoubleID=NULL;
117 jdoubleArray_getGraphicObjectPropertyAsDoubleVectorjintintjintintID=NULL;
118 jbooleansetGraphicObjectPropertyjintintjintintjdoubleArray_doubledoubleID=NULL;
119 jbooleansetGraphicObjectPropertyjintintjintintjintintID=NULL;
120 jintArray_getGraphicObjectPropertyAsIntegerVectorjintintjintintID=NULL;
121 jbooleansetGraphicObjectPropertyjintintjintintjintArray_intintID=NULL;
122 jbooleansetGraphicObjectPropertyjintintjintintjbooleanbooleanID=NULL;
123 jintArray_getGraphicObjectPropertyAsBooleanVectorjintintjintintID=NULL;
124 jbooleansetGraphicObjectPropertyjintintjintintjbooleanArray_booleanbooleanID=NULL;
125 voidregisterScilabViewID=NULL;
126 voidunregisterScilabViewID=NULL;
127 jintgetConsoleIdentifierID=NULL;
128 voidbuildFigureMenuBarjintintID=NULL;
129
130
131 }
132
133 CallGraphicController::CallGraphicController(JavaVM * jvm_, jobject JObj) {
134         jvm=jvm_;
135
136         JNIEnv * curEnv = getCurrentEnv();
137
138 jclass localClass = curEnv->GetObjectClass(JObj);
139         this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
140         curEnv->DeleteLocalRef(localClass);
141
142         if (this->instanceClass == NULL) {
143 throw GiwsException::JniObjectCreationException(curEnv, this->className());
144         }
145
146         this->instance = curEnv->NewGlobalRef(JObj) ;
147         if(this->instance == NULL){
148 throw GiwsException::JniObjectCreationException(curEnv, this->className());
149         }
150         /* Methods ID set to NULL */
151         voiddeleteGraphicObjectjintintID=NULL;
152 jintcloneGraphicObjectjintintID=NULL;
153 jintaskGraphicObjectjintintID=NULL;
154 voidsetGraphicObjectRelationshipjintintjintintID=NULL;
155 voidremoveRelationShipAndDeletejintintID=NULL;
156 jstringgetGraphicObjectPropertyAsStringjintintjintintID=NULL;
157 jbooleansetGraphicObjectPropertyjintintjintintjstringjava_lang_StringID=NULL;
158 jobjectArray_getGraphicObjectPropertyAsStringVectorjintintjintintID=NULL;
159 jbooleansetGraphicObjectPropertyjintintjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
160 jbooleansetGraphicObjectPropertyjintintjintintjdoubledoubleID=NULL;
161 jdoubleArray_getGraphicObjectPropertyAsDoubleVectorjintintjintintID=NULL;
162 jbooleansetGraphicObjectPropertyjintintjintintjdoubleArray_doubledoubleID=NULL;
163 jbooleansetGraphicObjectPropertyjintintjintintjintintID=NULL;
164 jintArray_getGraphicObjectPropertyAsIntegerVectorjintintjintintID=NULL;
165 jbooleansetGraphicObjectPropertyjintintjintintjintArray_intintID=NULL;
166 jbooleansetGraphicObjectPropertyjintintjintintjbooleanbooleanID=NULL;
167 jintArray_getGraphicObjectPropertyAsBooleanVectorjintintjintintID=NULL;
168 jbooleansetGraphicObjectPropertyjintintjintintjbooleanArray_booleanbooleanID=NULL;
169 voidregisterScilabViewID=NULL;
170 voidunregisterScilabViewID=NULL;
171 jintgetConsoleIdentifierID=NULL;
172 voidbuildFigureMenuBarjintintID=NULL;
173
174
175 }
176
177 // Generic methods
178
179 void CallGraphicController::synchronize() {
180 if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
181 throw GiwsException::JniMonitorException(getCurrentEnv(), "CallGraphicController");
182 }
183 }
184
185 void CallGraphicController::endSynchronize() {
186 if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
187 throw GiwsException::JniMonitorException(getCurrentEnv(), "CallGraphicController");
188 }
189 }
190 // Method(s)
191
192 void CallGraphicController::deleteGraphicObject (JavaVM * jvm_, int id){
193
194 JNIEnv * curEnv = NULL;
195 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
196 jclass cls = curEnv->FindClass( className().c_str() );
197
198 jmethodID voiddeleteGraphicObjectjintintID = curEnv->GetStaticMethodID(cls, "deleteGraphicObject", "(I)V" ) ;
199 if (voiddeleteGraphicObjectjintintID == NULL) {
200 throw GiwsException::JniMethodNotFoundException(curEnv, "deleteGraphicObject");
201 }
202
203                          curEnv->CallStaticVoidMethod(cls, voiddeleteGraphicObjectjintintID ,id);
204                         curEnv->DeleteLocalRef(cls);
205 if (curEnv->ExceptionCheck()) {
206 throw GiwsException::JniCallMethodException(curEnv);
207 }
208 }
209
210 int CallGraphicController::cloneGraphicObject (JavaVM * jvm_, int id){
211
212 JNIEnv * curEnv = NULL;
213 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
214 jclass cls = curEnv->FindClass( className().c_str() );
215
216 jmethodID jintcloneGraphicObjectjintintID = curEnv->GetStaticMethodID(cls, "cloneGraphicObject", "(I)I" ) ;
217 if (jintcloneGraphicObjectjintintID == NULL) {
218 throw GiwsException::JniMethodNotFoundException(curEnv, "cloneGraphicObject");
219 }
220
221                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcloneGraphicObjectjintintID ,id));
222                         curEnv->DeleteLocalRef(cls);
223 if (curEnv->ExceptionCheck()) {
224 throw GiwsException::JniCallMethodException(curEnv);
225 }
226 return res;
227
228 }
229
230 int CallGraphicController::askGraphicObject (JavaVM * jvm_, int typeName){
231
232 JNIEnv * curEnv = NULL;
233 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
234 jclass cls = curEnv->FindClass( className().c_str() );
235
236 jmethodID jintaskGraphicObjectjintintID = curEnv->GetStaticMethodID(cls, "askGraphicObject", "(I)I" ) ;
237 if (jintaskGraphicObjectjintintID == NULL) {
238 throw GiwsException::JniMethodNotFoundException(curEnv, "askGraphicObject");
239 }
240
241                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintaskGraphicObjectjintintID ,typeName));
242                         curEnv->DeleteLocalRef(cls);
243 if (curEnv->ExceptionCheck()) {
244 throw GiwsException::JniCallMethodException(curEnv);
245 }
246 return res;
247
248 }
249
250 void CallGraphicController::setGraphicObjectRelationship (JavaVM * jvm_, int parentId, int childId){
251
252 JNIEnv * curEnv = NULL;
253 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
254 jclass cls = curEnv->FindClass( className().c_str() );
255
256 jmethodID voidsetGraphicObjectRelationshipjintintjintintID = curEnv->GetStaticMethodID(cls, "setGraphicObjectRelationship", "(II)V" ) ;
257 if (voidsetGraphicObjectRelationshipjintintjintintID == NULL) {
258 throw GiwsException::JniMethodNotFoundException(curEnv, "setGraphicObjectRelationship");
259 }
260
261                          curEnv->CallStaticVoidMethod(cls, voidsetGraphicObjectRelationshipjintintjintintID ,parentId, childId);
262                         curEnv->DeleteLocalRef(cls);
263 if (curEnv->ExceptionCheck()) {
264 throw GiwsException::JniCallMethodException(curEnv);
265 }
266 }
267
268 void CallGraphicController::removeRelationShipAndDelete (JavaVM * jvm_, int id){
269
270 JNIEnv * curEnv = NULL;
271 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
272 jclass cls = curEnv->FindClass( className().c_str() );
273
274 jmethodID voidremoveRelationShipAndDeletejintintID = curEnv->GetStaticMethodID(cls, "removeRelationShipAndDelete", "(I)V" ) ;
275 if (voidremoveRelationShipAndDeletejintintID == NULL) {
276 throw GiwsException::JniMethodNotFoundException(curEnv, "removeRelationShipAndDelete");
277 }
278
279                          curEnv->CallStaticVoidMethod(cls, voidremoveRelationShipAndDeletejintintID ,id);
280                         curEnv->DeleteLocalRef(cls);
281 if (curEnv->ExceptionCheck()) {
282 throw GiwsException::JniCallMethodException(curEnv);
283 }
284 }
285
286 char* CallGraphicController::getGraphicObjectPropertyAsString (JavaVM * jvm_, int id, int propertyName){
287
288 JNIEnv * curEnv = NULL;
289 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
290 jclass cls = curEnv->FindClass( className().c_str() );
291
292 jmethodID jstringgetGraphicObjectPropertyAsStringjintintjintintID = curEnv->GetStaticMethodID(cls, "getGraphicObjectPropertyAsString", "(II)Ljava/lang/String;" ) ;
293 if (jstringgetGraphicObjectPropertyAsStringjintintjintintID == NULL) {
294 throw GiwsException::JniMethodNotFoundException(curEnv, "getGraphicObjectPropertyAsString");
295 }
296
297                         jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringgetGraphicObjectPropertyAsStringjintintjintintID ,id, propertyName));
298                         if (curEnv->ExceptionCheck()) {
299 throw GiwsException::JniCallMethodException(curEnv);
300 }if (res != NULL) { 
301
302 const char *tempString = curEnv->GetStringUTFChars(res, 0);
303 char * myStringBuffer = new char[strlen(tempString) + 1];
304 strcpy(myStringBuffer, tempString);
305 curEnv->ReleaseStringUTFChars(res, tempString);
306 curEnv->DeleteLocalRef(res);
307 curEnv->DeleteLocalRef(cls);
308 if (curEnv->ExceptionCheck()) {
309 delete[] myStringBuffer;
310                                 throw GiwsException::JniCallMethodException(curEnv);
311 }
312 return myStringBuffer;
313  } else { 
314 curEnv->DeleteLocalRef(res);
315 return NULL;
316 }
317 }
318
319 bool CallGraphicController::setGraphicObjectProperty (JavaVM * jvm_, int id, int propertyName, char const* value){
320
321 JNIEnv * curEnv = NULL;
322 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
323 jclass cls = curEnv->FindClass( className().c_str() );
324
325 jmethodID jbooleansetGraphicObjectPropertyjintintjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setGraphicObjectProperty", "(IILjava/lang/String;)Z" ) ;
326 if (jbooleansetGraphicObjectPropertyjintintjintintjstringjava_lang_StringID == NULL) {
327 throw GiwsException::JniMethodNotFoundException(curEnv, "setGraphicObjectProperty");
328 }
329
330 jstring value_ = curEnv->NewStringUTF( value );
331 if (value != NULL && value_ == NULL)
332 {
333 throw GiwsException::JniBadAllocException(curEnv);
334 }
335
336
337                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleansetGraphicObjectPropertyjintintjintintjstringjava_lang_StringID ,id, propertyName, value_));
338                         curEnv->DeleteLocalRef(value_);
339 curEnv->DeleteLocalRef(cls);
340 if (curEnv->ExceptionCheck()) {
341 throw GiwsException::JniCallMethodException(curEnv);
342 }
343 return (res == JNI_TRUE);
344
345 }
346
347 char** CallGraphicController::getGraphicObjectPropertyAsStringVector (JavaVM * jvm_, int id, int propertyName){
348
349 JNIEnv * curEnv = NULL;
350 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
351 jclass cls = curEnv->FindClass( className().c_str() );
352
353 jmethodID jobjectArray_getGraphicObjectPropertyAsStringVectorjintintjintintID = curEnv->GetStaticMethodID(cls, "getGraphicObjectPropertyAsStringVector", "(II)[Ljava/lang/String;" ) ;
354 if (jobjectArray_getGraphicObjectPropertyAsStringVectorjintintjintintID == NULL) {
355 throw GiwsException::JniMethodNotFoundException(curEnv, "getGraphicObjectPropertyAsStringVector");
356 }
357
358                         jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray_getGraphicObjectPropertyAsStringVectorjintintjintintID ,id, propertyName));
359                         if (curEnv->ExceptionCheck()) {
360 throw GiwsException::JniCallMethodException(curEnv);
361 }if (res != NULL) { int lenRow;
362  lenRow = curEnv->GetArrayLength(res);
363
364 char **arrayOfString;
365 arrayOfString = new char *[lenRow];
366 for (jsize i = 0; i < lenRow; i++){
367 jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
368 const char *tempString = curEnv->GetStringUTFChars(resString, 0);
369 arrayOfString[i] = new char[strlen(tempString) + 1];
370
371 strcpy(arrayOfString[i], tempString);
372 curEnv->ReleaseStringUTFChars(resString, tempString);
373 curEnv->DeleteLocalRef(resString);
374 }
375 curEnv->DeleteLocalRef(cls);
376 if (curEnv->ExceptionCheck()) {
377 delete[] arrayOfString;
378                                 throw GiwsException::JniCallMethodException(curEnv);
379 }
380 curEnv->DeleteLocalRef(res);
381 return arrayOfString;
382  } else { 
383 curEnv->DeleteLocalRef(res);
384 return NULL;
385 }
386 }
387
388 bool CallGraphicController::setGraphicObjectProperty (JavaVM * jvm_, int id, int propertyName, char const* const* value, int valueSize){
389
390 JNIEnv * curEnv = NULL;
391 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
392 jclass cls = curEnv->FindClass( className().c_str() );
393
394 jmethodID jbooleansetGraphicObjectPropertyjintintjintintjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setGraphicObjectProperty", "(II[Ljava/lang/String;)Z" ) ;
395 if (jbooleansetGraphicObjectPropertyjintintjintintjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
396 throw GiwsException::JniMethodNotFoundException(curEnv, "setGraphicObjectProperty");
397 }
398 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
399
400 // create java array of strings.
401 jobjectArray value_ = curEnv->NewObjectArray( valueSize, stringArrayClass, NULL);
402 if (value_ == NULL)
403 {
404 throw GiwsException::JniBadAllocException(curEnv);
405 }
406
407 // convert each char * to java strings and fill the java array.
408 for ( int i = 0; i < valueSize; i++)
409 {
410 jstring TempString = curEnv->NewStringUTF( value[i] );
411 if (TempString == NULL)
412 {
413 throw GiwsException::JniBadAllocException(curEnv);
414 }
415
416 curEnv->SetObjectArrayElement( value_, i, TempString);
417
418 // avoid keeping reference on to many strings
419 curEnv->DeleteLocalRef(TempString);
420 }
421                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleansetGraphicObjectPropertyjintintjintintjobjectArray_java_lang_Stringjava_lang_StringID ,id, propertyName, value_));
422                         curEnv->DeleteLocalRef(stringArrayClass);
423 curEnv->DeleteLocalRef(value_);
424 curEnv->DeleteLocalRef(cls);
425 if (curEnv->ExceptionCheck()) {
426 throw GiwsException::JniCallMethodException(curEnv);
427 }
428 return (res == JNI_TRUE);
429
430 }
431
432 bool CallGraphicController::setGraphicObjectProperty (JavaVM * jvm_, int id, int propertyName, double value){
433
434 JNIEnv * curEnv = NULL;
435 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
436 jclass cls = curEnv->FindClass( className().c_str() );
437
438 jmethodID jbooleansetGraphicObjectPropertyjintintjintintjdoubledoubleID = curEnv->GetStaticMethodID(cls, "setGraphicObjectProperty", "(IID)Z" ) ;
439 if (jbooleansetGraphicObjectPropertyjintintjintintjdoubledoubleID == NULL) {
440 throw GiwsException::JniMethodNotFoundException(curEnv, "setGraphicObjectProperty");
441 }
442
443                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleansetGraphicObjectPropertyjintintjintintjdoubledoubleID ,id, propertyName, value));
444                         curEnv->DeleteLocalRef(cls);
445 if (curEnv->ExceptionCheck()) {
446 throw GiwsException::JniCallMethodException(curEnv);
447 }
448 return (res == JNI_TRUE);
449
450 }
451
452 double* CallGraphicController::getGraphicObjectPropertyAsDoubleVector (JavaVM * jvm_, int id, int propertyName){
453
454 JNIEnv * curEnv = NULL;
455 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
456 jclass cls = curEnv->FindClass( className().c_str() );
457
458 jmethodID jdoubleArray_getGraphicObjectPropertyAsDoubleVectorjintintjintintID = curEnv->GetStaticMethodID(cls, "getGraphicObjectPropertyAsDoubleVector", "(II)[D" ) ;
459 if (jdoubleArray_getGraphicObjectPropertyAsDoubleVectorjintintjintintID == NULL) {
460 throw GiwsException::JniMethodNotFoundException(curEnv, "getGraphicObjectPropertyAsDoubleVector");
461 }
462
463                         jdoubleArray res =  static_cast<jdoubleArray>( curEnv->CallStaticObjectMethod(cls, jdoubleArray_getGraphicObjectPropertyAsDoubleVectorjintintjintintID ,id, propertyName));
464                         if (res == NULL) { return NULL; }
465                         if (curEnv->ExceptionCheck()) {
466 throw GiwsException::JniCallMethodException(curEnv);
467 }int lenRow;
468  lenRow = curEnv->GetArrayLength(res);
469 jboolean isCopy = JNI_FALSE;
470
471 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
472 jdouble *resultsArray = static_cast<jdouble *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
473 double* myArray= new double[ lenRow];
474
475 for (jsize i = 0; i <  lenRow; i++){
476 myArray[i]=resultsArray[i];
477 }
478 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
479
480                         curEnv->DeleteLocalRef(res);
481 curEnv->DeleteLocalRef(cls);
482 if (curEnv->ExceptionCheck()) {
483 delete[] myArray;
484                                 throw GiwsException::JniCallMethodException(curEnv);
485 }
486 return myArray;
487
488 }
489
490 bool CallGraphicController::setGraphicObjectProperty (JavaVM * jvm_, int id, int propertyName, double const* value, int valueSize){
491
492 JNIEnv * curEnv = NULL;
493 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
494 jclass cls = curEnv->FindClass( className().c_str() );
495
496 jmethodID jbooleansetGraphicObjectPropertyjintintjintintjdoubleArray_doubledoubleID = curEnv->GetStaticMethodID(cls, "setGraphicObjectProperty", "(II[D)Z" ) ;
497 if (jbooleansetGraphicObjectPropertyjintintjintintjdoubleArray_doubledoubleID == NULL) {
498 throw GiwsException::JniMethodNotFoundException(curEnv, "setGraphicObjectProperty");
499 }
500
501 jdoubleArray value_ = curEnv->NewDoubleArray( valueSize ) ;
502
503 if (value_ == NULL)
504 {
505 // check that allocation succeed
506 throw GiwsException::JniBadAllocException(curEnv);
507 }
508
509 curEnv->SetDoubleArrayRegion( value_, 0, valueSize, (jdouble*)(value) ) ;
510
511
512                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleansetGraphicObjectPropertyjintintjintintjdoubleArray_doubledoubleID ,id, propertyName, value_));
513                         curEnv->DeleteLocalRef(value_);
514 curEnv->DeleteLocalRef(cls);
515 if (curEnv->ExceptionCheck()) {
516 throw GiwsException::JniCallMethodException(curEnv);
517 }
518 return (res == JNI_TRUE);
519
520 }
521
522 bool CallGraphicController::setGraphicObjectProperty (JavaVM * jvm_, int id, int propertyName, int value){
523
524 JNIEnv * curEnv = NULL;
525 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
526 jclass cls = curEnv->FindClass( className().c_str() );
527
528 jmethodID jbooleansetGraphicObjectPropertyjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "setGraphicObjectProperty", "(III)Z" ) ;
529 if (jbooleansetGraphicObjectPropertyjintintjintintjintintID == NULL) {
530 throw GiwsException::JniMethodNotFoundException(curEnv, "setGraphicObjectProperty");
531 }
532
533                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleansetGraphicObjectPropertyjintintjintintjintintID ,id, propertyName, value));
534                         curEnv->DeleteLocalRef(cls);
535 if (curEnv->ExceptionCheck()) {
536 throw GiwsException::JniCallMethodException(curEnv);
537 }
538 return (res == JNI_TRUE);
539
540 }
541
542 int* CallGraphicController::getGraphicObjectPropertyAsIntegerVector (JavaVM * jvm_, int id, int propertyName){
543
544 JNIEnv * curEnv = NULL;
545 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
546 jclass cls = curEnv->FindClass( className().c_str() );
547
548 jmethodID jintArray_getGraphicObjectPropertyAsIntegerVectorjintintjintintID = curEnv->GetStaticMethodID(cls, "getGraphicObjectPropertyAsIntegerVector", "(II)[I" ) ;
549 if (jintArray_getGraphicObjectPropertyAsIntegerVectorjintintjintintID == NULL) {
550 throw GiwsException::JniMethodNotFoundException(curEnv, "getGraphicObjectPropertyAsIntegerVector");
551 }
552
553                         jintArray res =  static_cast<jintArray>( curEnv->CallStaticObjectMethod(cls, jintArray_getGraphicObjectPropertyAsIntegerVectorjintintjintintID ,id, propertyName));
554                         if (res == NULL) { return NULL; }
555                         if (curEnv->ExceptionCheck()) {
556 throw GiwsException::JniCallMethodException(curEnv);
557 }int lenRow;
558  lenRow = curEnv->GetArrayLength(res);
559 jboolean isCopy = JNI_FALSE;
560
561 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
562 jint *resultsArray = static_cast<jint *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
563 int* myArray= new int[ lenRow];
564
565 for (jsize i = 0; i <  lenRow; i++){
566 myArray[i]=resultsArray[i];
567 }
568 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
569
570                         curEnv->DeleteLocalRef(res);
571 curEnv->DeleteLocalRef(cls);
572 if (curEnv->ExceptionCheck()) {
573 delete[] myArray;
574                                 throw GiwsException::JniCallMethodException(curEnv);
575 }
576 return myArray;
577
578 }
579
580 bool CallGraphicController::setGraphicObjectProperty (JavaVM * jvm_, int id, int propertyName, int const* value, int valueSize){
581
582 JNIEnv * curEnv = NULL;
583 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
584 jclass cls = curEnv->FindClass( className().c_str() );
585
586 jmethodID jbooleansetGraphicObjectPropertyjintintjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "setGraphicObjectProperty", "(II[I)Z" ) ;
587 if (jbooleansetGraphicObjectPropertyjintintjintintjintArray_intintID == NULL) {
588 throw GiwsException::JniMethodNotFoundException(curEnv, "setGraphicObjectProperty");
589 }
590
591 jintArray value_ = curEnv->NewIntArray( valueSize ) ;
592
593 if (value_ == NULL)
594 {
595 // check that allocation succeed
596 throw GiwsException::JniBadAllocException(curEnv);
597 }
598
599 curEnv->SetIntArrayRegion( value_, 0, valueSize, (jint*)(value) ) ;
600
601
602                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleansetGraphicObjectPropertyjintintjintintjintArray_intintID ,id, propertyName, value_));
603                         curEnv->DeleteLocalRef(value_);
604 curEnv->DeleteLocalRef(cls);
605 if (curEnv->ExceptionCheck()) {
606 throw GiwsException::JniCallMethodException(curEnv);
607 }
608 return (res == JNI_TRUE);
609
610 }
611
612 bool CallGraphicController::setGraphicObjectProperty (JavaVM * jvm_, int id, int propertyName, bool value){
613
614 JNIEnv * curEnv = NULL;
615 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
616 jclass cls = curEnv->FindClass( className().c_str() );
617
618 jmethodID jbooleansetGraphicObjectPropertyjintintjintintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "setGraphicObjectProperty", "(IIZ)Z" ) ;
619 if (jbooleansetGraphicObjectPropertyjintintjintintjbooleanbooleanID == NULL) {
620 throw GiwsException::JniMethodNotFoundException(curEnv, "setGraphicObjectProperty");
621 }
622
623 jboolean value_ = (static_cast<bool>(value) ? JNI_TRUE : JNI_FALSE);
624
625                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleansetGraphicObjectPropertyjintintjintintjbooleanbooleanID ,id, propertyName, value_));
626                         curEnv->DeleteLocalRef(cls);
627 if (curEnv->ExceptionCheck()) {
628 throw GiwsException::JniCallMethodException(curEnv);
629 }
630 return (res == JNI_TRUE);
631
632 }
633
634 int* CallGraphicController::getGraphicObjectPropertyAsBooleanVector (JavaVM * jvm_, int id, int propertyName){
635
636 JNIEnv * curEnv = NULL;
637 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
638 jclass cls = curEnv->FindClass( className().c_str() );
639
640 jmethodID jintArray_getGraphicObjectPropertyAsBooleanVectorjintintjintintID = curEnv->GetStaticMethodID(cls, "getGraphicObjectPropertyAsBooleanVector", "(II)[I" ) ;
641 if (jintArray_getGraphicObjectPropertyAsBooleanVectorjintintjintintID == NULL) {
642 throw GiwsException::JniMethodNotFoundException(curEnv, "getGraphicObjectPropertyAsBooleanVector");
643 }
644
645                         jintArray res =  static_cast<jintArray>( curEnv->CallStaticObjectMethod(cls, jintArray_getGraphicObjectPropertyAsBooleanVectorjintintjintintID ,id, propertyName));
646                         if (res == NULL) { return NULL; }
647                         if (curEnv->ExceptionCheck()) {
648 throw GiwsException::JniCallMethodException(curEnv);
649 }int lenRow;
650  lenRow = curEnv->GetArrayLength(res);
651 jboolean isCopy = JNI_FALSE;
652
653 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
654 jint *resultsArray = static_cast<jint *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
655 int* myArray= new int[ lenRow];
656
657 for (jsize i = 0; i <  lenRow; i++){
658 myArray[i]=resultsArray[i];
659 }
660 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
661
662                         curEnv->DeleteLocalRef(res);
663 curEnv->DeleteLocalRef(cls);
664 if (curEnv->ExceptionCheck()) {
665 delete[] myArray;
666                                 throw GiwsException::JniCallMethodException(curEnv);
667 }
668 return myArray;
669
670 }
671
672 bool CallGraphicController::setGraphicObjectProperty (JavaVM * jvm_, int id, int propertyName, bool const* value, int valueSize){
673
674 JNIEnv * curEnv = NULL;
675 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
676 jclass cls = curEnv->FindClass( className().c_str() );
677
678 jmethodID jbooleansetGraphicObjectPropertyjintintjintintjbooleanArray_booleanbooleanID = curEnv->GetStaticMethodID(cls, "setGraphicObjectProperty", "(II[Z)Z" ) ;
679 if (jbooleansetGraphicObjectPropertyjintintjintintjbooleanArray_booleanbooleanID == NULL) {
680 throw GiwsException::JniMethodNotFoundException(curEnv, "setGraphicObjectProperty");
681 }
682
683 jbooleanArray value_ = curEnv->NewBooleanArray( valueSize ) ;
684 curEnv->SetBooleanArrayRegion( value_, 0, valueSize, (jboolean*)value ) ;
685
686                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleansetGraphicObjectPropertyjintintjintintjbooleanArray_booleanbooleanID ,id, propertyName, value_));
687                         curEnv->DeleteLocalRef(value_);
688 curEnv->DeleteLocalRef(cls);
689 if (curEnv->ExceptionCheck()) {
690 throw GiwsException::JniCallMethodException(curEnv);
691 }
692 return (res == JNI_TRUE);
693
694 }
695
696 void CallGraphicController::registerScilabView (JavaVM * jvm_){
697
698 JNIEnv * curEnv = NULL;
699 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
700 jclass cls = curEnv->FindClass( className().c_str() );
701
702 jmethodID voidregisterScilabViewID = curEnv->GetStaticMethodID(cls, "registerScilabView", "()V" ) ;
703 if (voidregisterScilabViewID == NULL) {
704 throw GiwsException::JniMethodNotFoundException(curEnv, "registerScilabView");
705 }
706
707                          curEnv->CallStaticVoidMethod(cls, voidregisterScilabViewID );
708                         curEnv->DeleteLocalRef(cls);
709 if (curEnv->ExceptionCheck()) {
710 throw GiwsException::JniCallMethodException(curEnv);
711 }
712 }
713
714 void CallGraphicController::unregisterScilabView (JavaVM * jvm_){
715
716 JNIEnv * curEnv = NULL;
717 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
718 jclass cls = curEnv->FindClass( className().c_str() );
719
720 jmethodID voidunregisterScilabViewID = curEnv->GetStaticMethodID(cls, "unregisterScilabView", "()V" ) ;
721 if (voidunregisterScilabViewID == NULL) {
722 throw GiwsException::JniMethodNotFoundException(curEnv, "unregisterScilabView");
723 }
724
725                          curEnv->CallStaticVoidMethod(cls, voidunregisterScilabViewID );
726                         curEnv->DeleteLocalRef(cls);
727 if (curEnv->ExceptionCheck()) {
728 throw GiwsException::JniCallMethodException(curEnv);
729 }
730 }
731
732 int CallGraphicController::getConsoleIdentifier (JavaVM * jvm_){
733
734 JNIEnv * curEnv = NULL;
735 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
736 jclass cls = curEnv->FindClass( className().c_str() );
737
738 jmethodID jintgetConsoleIdentifierID = curEnv->GetStaticMethodID(cls, "getConsoleIdentifier", "()I" ) ;
739 if (jintgetConsoleIdentifierID == NULL) {
740 throw GiwsException::JniMethodNotFoundException(curEnv, "getConsoleIdentifier");
741 }
742
743                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetConsoleIdentifierID ));
744                         curEnv->DeleteLocalRef(cls);
745 if (curEnv->ExceptionCheck()) {
746 throw GiwsException::JniCallMethodException(curEnv);
747 }
748 return res;
749
750 }
751
752 void CallGraphicController::buildFigureMenuBar (JavaVM * jvm_, int figureId){
753
754 JNIEnv * curEnv = NULL;
755 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
756 jclass cls = curEnv->FindClass( className().c_str() );
757
758 jmethodID voidbuildFigureMenuBarjintintID = curEnv->GetStaticMethodID(cls, "buildFigureMenuBar", "(I)V" ) ;
759 if (voidbuildFigureMenuBarjintintID == NULL) {
760 throw GiwsException::JniMethodNotFoundException(curEnv, "buildFigureMenuBar");
761 }
762
763                          curEnv->CallStaticVoidMethod(cls, voidbuildFigureMenuBarjintintID ,figureId);
764                         curEnv->DeleteLocalRef(cls);
765 if (curEnv->ExceptionCheck()) {
766 throw GiwsException::JniCallMethodException(curEnv);
767 }
768 }
769
770 }