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