f114460667486a4c390f5fb48f945c16842a7293
[scilab.git] / scilab / modules / gui / src / jni / CallScilabBridge.cpp
1 #include "CallScilabBridge.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/CallScilabBridge.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 Copyright (C) 2012 - 2016 - Scilab Enterprises
13
14 This file is hereby licensed under the terms of the GNU GPL v2.0,
15 pursuant to article 5.3.4 of the CeCILL v.2.1.
16 This file was originally licensed under the terms of the CeCILL v2.1,
17 and continues to be available under such terms.
18 For more information, see the COPYING file which you should have received
19 along with this program.
20 */
21
22 namespace org_scilab_modules_gui_bridge {
23
24                 // Static declarations (if any)
25                 
26 // Returns the current env
27
28 JNIEnv * CallScilabBridge::getCurrentEnv() {
29 JNIEnv * curEnv = NULL;
30 jint res=this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
31 if (res != JNI_OK) {
32 throw GiwsException::JniException(getCurrentEnv());
33 }
34 return curEnv;
35 }
36 // Destructor
37
38 CallScilabBridge::~CallScilabBridge() {
39 JNIEnv * curEnv = NULL;
40 this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
41 curEnv->DeleteGlobalRef(this->instance);
42 curEnv->DeleteGlobalRef(this->instanceClass);
43 curEnv->DeleteGlobalRef(this->stringArrayClass);}
44 // Constructors
45 CallScilabBridge::CallScilabBridge(JavaVM * jvm_) {
46 jmethodID constructObject = NULL ;
47 jobject localInstance ;
48 jclass localClass ;
49
50 const std::string construct="<init>";
51 const std::string param="()V";
52 jvm=jvm_;
53
54 JNIEnv * curEnv = getCurrentEnv();
55
56 localClass = curEnv->FindClass( this->className().c_str() ) ;
57 if (localClass == NULL) {
58   throw GiwsException::JniClassNotFoundException(curEnv, this->className());
59 }
60
61 this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
62
63 /* localClass is not needed anymore */
64 curEnv->DeleteLocalRef(localClass);
65
66 if (this->instanceClass == NULL) {
67 throw GiwsException::JniObjectCreationException(curEnv, this->className());
68 }
69
70
71 constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
72 if(constructObject == NULL){
73 throw GiwsException::JniObjectCreationException(curEnv, this->className());
74 }
75
76 localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
77 if(localInstance == NULL){
78 throw GiwsException::JniObjectCreationException(curEnv, this->className());
79 }
80  
81 this->instance = curEnv->NewGlobalRef(localInstance) ;
82 if(this->instance == NULL){
83 throw GiwsException::JniObjectCreationException(curEnv, this->className());
84 }
85 /* localInstance not needed anymore */
86 curEnv->DeleteLocalRef(localInstance);
87
88                 /* Methods ID set to NULL */
89 voidsetMenuEnabledjintintjstringjava_lang_StringjbooleanbooleanID=NULL;
90 voidsetSubMenuEnabledjintintjstringjava_lang_StringjintintjbooleanbooleanID=NULL;
91 voidremoveMenujintintjstringjava_lang_StringID=NULL;
92 jstringdisplayAndWaitContextMenujintintID=NULL;
93 jintnewMessageBoxID=NULL;
94 voidsetMessageBoxTitlejintintjstringjava_lang_StringID=NULL;
95 voidsetMessageBoxMessagejintintjstringjava_lang_StringID=NULL;
96 voidsetMessageBoxMessagejintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
97 voidmessageBoxDisplayAndWaitjintintID=NULL;
98 jintgetMessageBoxSelectedButtonjintintID=NULL;
99 voidsetMessageBoxDefaultSelectedButtonsjintintjintArray_intintID=NULL;
100 jintArray_getMessageBoxUserSelectedButtonsjintintID=NULL;
101 voidsetMessageBoxButtonsLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
102 voidsetMessageBoxInitialValuejintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
103 jobjectArray_getMessageBoxValuejintintID=NULL;
104 jintgetMessageBoxValueSizejintintID=NULL;
105 voidsetMessageBoxListBoxItemsjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
106 jintgetMessageBoxSelectedItemjintintID=NULL;
107 voidsetMessageBoxLineLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
108 voidsetMessageBoxColumnLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
109 voidsetMessageBoxDefaultInputjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
110 voidsetMessageBoxModaljintintjbooleanbooleanID=NULL;
111 voidsetMessageBoxIconjintintjstringjava_lang_StringID=NULL;
112 voidlaunchHelpBrowserjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_StringID=NULL;
113 voidsearchKeywordjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID=NULL;
114 jintnewExportFileChooserjintintID=NULL;
115 jintnewFontChooserID=NULL;
116 voidfontChooserDisplayAndWaitjintintID=NULL;
117 voidsetFontChooserFontNamejintintjstringjava_lang_StringID=NULL;
118 voidsetFontChooserFontSizejintintjintintID=NULL;
119 voidsetFontChooserBoldjintintjbooleanbooleanID=NULL;
120 voidsetFontChooserItalicjintintjbooleanbooleanID=NULL;
121 jstringgetFontChooserFontNamejintintID=NULL;
122 jintgetFontChooserFontSizejintintID=NULL;
123 jbooleangetFontChooserBoldjintintID=NULL;
124 jbooleangetFontChooserItalicjintintID=NULL;
125 jintnewColorChooserID=NULL;
126 voidcolorChooserDisplayAndWaitjintintID=NULL;
127 voidsetColorChooserDefaultColorjintintjintArray_intintID=NULL;
128 jintArray_getColorChooserSelectedColorjintintID=NULL;
129 voidsetColorChooserTitlejintintjstringjava_lang_StringID=NULL;
130 jstringgetClipboardContentsID=NULL;
131 voidpasteClipboardIntoConsoleID=NULL;
132 voidcopyConsoleSelectionID=NULL;
133 voidemptyClipboardID=NULL;
134 voidsetClipboardContentsjstringjava_lang_StringID=NULL;
135 voidcopyFigureToClipBoardjintintID=NULL;
136 jintgetScreenResolutionID=NULL;
137 jdoublegetScreenWidthID=NULL;
138 jdoublegetScreenHeightID=NULL;
139 jintgetScreenDepthID=NULL;
140 jbooleanprintFigurejintintjbooleanbooleanjbooleanbooleanID=NULL;
141 jbooleanprintFilejstringjava_lang_StringID=NULL;
142 jbooleanprintStringjstringjava_lang_Stringjstringjava_lang_StringID=NULL;
143 jbooleanpageSetupID=NULL;
144 voidrequestFocusjintintID=NULL;
145 voidraiseWindowjintintID=NULL;
146 voiduseCanvasForDisplayjbooleanbooleanID=NULL;
147 jbooleanuseCanvasForDisplayID=NULL;
148 voidscilabAboutBoxID=NULL;
149 voidfireClosingFinishedjintintID=NULL;
150
151
152 }
153
154 CallScilabBridge::CallScilabBridge(JavaVM * jvm_, jobject JObj) {
155         jvm=jvm_;
156
157         JNIEnv * curEnv = getCurrentEnv();
158
159 jclass localClass = curEnv->GetObjectClass(JObj);
160         this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
161         curEnv->DeleteLocalRef(localClass);
162
163         if (this->instanceClass == NULL) {
164 throw GiwsException::JniObjectCreationException(curEnv, this->className());
165         }
166
167         this->instance = curEnv->NewGlobalRef(JObj) ;
168         if(this->instance == NULL){
169 throw GiwsException::JniObjectCreationException(curEnv, this->className());
170         }
171         /* Methods ID set to NULL */
172         voidsetMenuEnabledjintintjstringjava_lang_StringjbooleanbooleanID=NULL;
173 voidsetSubMenuEnabledjintintjstringjava_lang_StringjintintjbooleanbooleanID=NULL;
174 voidremoveMenujintintjstringjava_lang_StringID=NULL;
175 jstringdisplayAndWaitContextMenujintintID=NULL;
176 jintnewMessageBoxID=NULL;
177 voidsetMessageBoxTitlejintintjstringjava_lang_StringID=NULL;
178 voidsetMessageBoxMessagejintintjstringjava_lang_StringID=NULL;
179 voidsetMessageBoxMessagejintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
180 voidmessageBoxDisplayAndWaitjintintID=NULL;
181 jintgetMessageBoxSelectedButtonjintintID=NULL;
182 voidsetMessageBoxDefaultSelectedButtonsjintintjintArray_intintID=NULL;
183 jintArray_getMessageBoxUserSelectedButtonsjintintID=NULL;
184 voidsetMessageBoxButtonsLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
185 voidsetMessageBoxInitialValuejintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
186 jobjectArray_getMessageBoxValuejintintID=NULL;
187 jintgetMessageBoxValueSizejintintID=NULL;
188 voidsetMessageBoxListBoxItemsjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
189 jintgetMessageBoxSelectedItemjintintID=NULL;
190 voidsetMessageBoxLineLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
191 voidsetMessageBoxColumnLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
192 voidsetMessageBoxDefaultInputjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
193 voidsetMessageBoxModaljintintjbooleanbooleanID=NULL;
194 voidsetMessageBoxIconjintintjstringjava_lang_StringID=NULL;
195 voidlaunchHelpBrowserjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_StringID=NULL;
196 voidsearchKeywordjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID=NULL;
197 jintnewExportFileChooserjintintID=NULL;
198 jintnewFontChooserID=NULL;
199 voidfontChooserDisplayAndWaitjintintID=NULL;
200 voidsetFontChooserFontNamejintintjstringjava_lang_StringID=NULL;
201 voidsetFontChooserFontSizejintintjintintID=NULL;
202 voidsetFontChooserBoldjintintjbooleanbooleanID=NULL;
203 voidsetFontChooserItalicjintintjbooleanbooleanID=NULL;
204 jstringgetFontChooserFontNamejintintID=NULL;
205 jintgetFontChooserFontSizejintintID=NULL;
206 jbooleangetFontChooserBoldjintintID=NULL;
207 jbooleangetFontChooserItalicjintintID=NULL;
208 jintnewColorChooserID=NULL;
209 voidcolorChooserDisplayAndWaitjintintID=NULL;
210 voidsetColorChooserDefaultColorjintintjintArray_intintID=NULL;
211 jintArray_getColorChooserSelectedColorjintintID=NULL;
212 voidsetColorChooserTitlejintintjstringjava_lang_StringID=NULL;
213 jstringgetClipboardContentsID=NULL;
214 voidpasteClipboardIntoConsoleID=NULL;
215 voidcopyConsoleSelectionID=NULL;
216 voidemptyClipboardID=NULL;
217 voidsetClipboardContentsjstringjava_lang_StringID=NULL;
218 voidcopyFigureToClipBoardjintintID=NULL;
219 jintgetScreenResolutionID=NULL;
220 jdoublegetScreenWidthID=NULL;
221 jdoublegetScreenHeightID=NULL;
222 jintgetScreenDepthID=NULL;
223 jbooleanprintFigurejintintjbooleanbooleanjbooleanbooleanID=NULL;
224 jbooleanprintFilejstringjava_lang_StringID=NULL;
225 jbooleanprintStringjstringjava_lang_Stringjstringjava_lang_StringID=NULL;
226 jbooleanpageSetupID=NULL;
227 voidrequestFocusjintintID=NULL;
228 voidraiseWindowjintintID=NULL;
229 voiduseCanvasForDisplayjbooleanbooleanID=NULL;
230 jbooleanuseCanvasForDisplayID=NULL;
231 voidscilabAboutBoxID=NULL;
232 voidfireClosingFinishedjintintID=NULL;
233
234
235 }
236
237 // Generic methods
238
239 void CallScilabBridge::synchronize() {
240 if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
241 throw GiwsException::JniMonitorException(getCurrentEnv(), "CallScilabBridge");
242 }
243 }
244
245 void CallScilabBridge::endSynchronize() {
246 if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
247 throw GiwsException::JniMonitorException(getCurrentEnv(), "CallScilabBridge");
248 }
249 }
250 // Method(s)
251
252 void CallScilabBridge::setMenuEnabled (JavaVM * jvm_, int parentUID, char const* menuName, bool status){
253
254 JNIEnv * curEnv = NULL;
255 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
256 jclass cls = initClass(curEnv);
257 if ( cls == NULL) {
258 throw GiwsException::JniCallMethodException(curEnv);
259 }
260
261 static jmethodID voidsetMenuEnabledjintintjstringjava_lang_StringjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "setMenuEnabled", "(ILjava/lang/String;Z)V" ) ;
262 if (voidsetMenuEnabledjintintjstringjava_lang_StringjbooleanbooleanID == NULL) {
263 throw GiwsException::JniMethodNotFoundException(curEnv, "setMenuEnabled");
264 }
265
266 jstring menuName_ = curEnv->NewStringUTF( menuName );
267 if (menuName != NULL && menuName_ == NULL)
268 {
269 throw GiwsException::JniBadAllocException(curEnv);
270 }
271
272
273 jboolean status_ = (static_cast<bool>(status) ? JNI_TRUE : JNI_FALSE);
274
275                          curEnv->CallStaticVoidMethod(cls, voidsetMenuEnabledjintintjstringjava_lang_StringjbooleanbooleanID ,parentUID, menuName_, status_);
276                         curEnv->DeleteLocalRef(menuName_);
277 if (curEnv->ExceptionCheck()) {
278 throw GiwsException::JniCallMethodException(curEnv);
279 }
280 }
281
282 void CallScilabBridge::setSubMenuEnabled (JavaVM * jvm_, int parentUID, char const* menuName, int position, bool status){
283
284 JNIEnv * curEnv = NULL;
285 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
286 jclass cls = initClass(curEnv);
287 if ( cls == NULL) {
288 throw GiwsException::JniCallMethodException(curEnv);
289 }
290
291 static jmethodID voidsetSubMenuEnabledjintintjstringjava_lang_StringjintintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "setSubMenuEnabled", "(ILjava/lang/String;IZ)V" ) ;
292 if (voidsetSubMenuEnabledjintintjstringjava_lang_StringjintintjbooleanbooleanID == NULL) {
293 throw GiwsException::JniMethodNotFoundException(curEnv, "setSubMenuEnabled");
294 }
295
296 jstring menuName_ = curEnv->NewStringUTF( menuName );
297 if (menuName != NULL && menuName_ == NULL)
298 {
299 throw GiwsException::JniBadAllocException(curEnv);
300 }
301
302
303 jboolean status_ = (static_cast<bool>(status) ? JNI_TRUE : JNI_FALSE);
304
305                          curEnv->CallStaticVoidMethod(cls, voidsetSubMenuEnabledjintintjstringjava_lang_StringjintintjbooleanbooleanID ,parentUID, menuName_, position, status_);
306                         curEnv->DeleteLocalRef(menuName_);
307 if (curEnv->ExceptionCheck()) {
308 throw GiwsException::JniCallMethodException(curEnv);
309 }
310 }
311
312 void CallScilabBridge::removeMenu (JavaVM * jvm_, int parentUID, char const* menuName){
313
314 JNIEnv * curEnv = NULL;
315 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
316 jclass cls = initClass(curEnv);
317 if ( cls == NULL) {
318 throw GiwsException::JniCallMethodException(curEnv);
319 }
320
321 static jmethodID voidremoveMenujintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "removeMenu", "(ILjava/lang/String;)V" ) ;
322 if (voidremoveMenujintintjstringjava_lang_StringID == NULL) {
323 throw GiwsException::JniMethodNotFoundException(curEnv, "removeMenu");
324 }
325
326 jstring menuName_ = curEnv->NewStringUTF( menuName );
327 if (menuName != NULL && menuName_ == NULL)
328 {
329 throw GiwsException::JniBadAllocException(curEnv);
330 }
331
332
333                          curEnv->CallStaticVoidMethod(cls, voidremoveMenujintintjstringjava_lang_StringID ,parentUID, menuName_);
334                         curEnv->DeleteLocalRef(menuName_);
335 if (curEnv->ExceptionCheck()) {
336 throw GiwsException::JniCallMethodException(curEnv);
337 }
338 }
339
340 char* CallScilabBridge::displayAndWaitContextMenu (JavaVM * jvm_, int UID){
341
342 JNIEnv * curEnv = NULL;
343 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
344 jclass cls = initClass(curEnv);
345 if ( cls == NULL) {
346 throw GiwsException::JniCallMethodException(curEnv);
347 }
348
349 static jmethodID jstringdisplayAndWaitContextMenujintintID = curEnv->GetStaticMethodID(cls, "displayAndWaitContextMenu", "(I)Ljava/lang/String;" ) ;
350 if (jstringdisplayAndWaitContextMenujintintID == NULL) {
351 throw GiwsException::JniMethodNotFoundException(curEnv, "displayAndWaitContextMenu");
352 }
353
354                         jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringdisplayAndWaitContextMenujintintID ,UID));
355                         if (curEnv->ExceptionCheck()) {
356 throw GiwsException::JniCallMethodException(curEnv);
357 }if (res != NULL) { 
358
359 const char *tempString = curEnv->GetStringUTFChars(res, 0);
360 char * myStringBuffer = new char[strlen(tempString) + 1];
361 strcpy(myStringBuffer, tempString);
362 curEnv->ReleaseStringUTFChars(res, tempString);
363 curEnv->DeleteLocalRef(res);
364 if (curEnv->ExceptionCheck()) {
365 delete[] myStringBuffer;
366                                 throw GiwsException::JniCallMethodException(curEnv);
367 }
368 return myStringBuffer;
369  } else { 
370 curEnv->DeleteLocalRef(res);
371 return NULL;
372 }
373 }
374
375 int CallScilabBridge::newMessageBox (JavaVM * jvm_){
376
377 JNIEnv * curEnv = NULL;
378 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
379 jclass cls = initClass(curEnv);
380 if ( cls == NULL) {
381 throw GiwsException::JniCallMethodException(curEnv);
382 }
383
384 static jmethodID jintnewMessageBoxID = curEnv->GetStaticMethodID(cls, "newMessageBox", "()I" ) ;
385 if (jintnewMessageBoxID == NULL) {
386 throw GiwsException::JniMethodNotFoundException(curEnv, "newMessageBox");
387 }
388
389                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewMessageBoxID ));
390                         if (curEnv->ExceptionCheck()) {
391 throw GiwsException::JniCallMethodException(curEnv);
392 }
393 return res;
394
395 }
396
397 void CallScilabBridge::setMessageBoxTitle (JavaVM * jvm_, int id, char const* title){
398
399 JNIEnv * curEnv = NULL;
400 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
401 jclass cls = initClass(curEnv);
402 if ( cls == NULL) {
403 throw GiwsException::JniCallMethodException(curEnv);
404 }
405
406 static jmethodID voidsetMessageBoxTitlejintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setMessageBoxTitle", "(ILjava/lang/String;)V" ) ;
407 if (voidsetMessageBoxTitlejintintjstringjava_lang_StringID == NULL) {
408 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxTitle");
409 }
410
411 jstring title_ = curEnv->NewStringUTF( title );
412 if (title != NULL && title_ == NULL)
413 {
414 throw GiwsException::JniBadAllocException(curEnv);
415 }
416
417
418                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxTitlejintintjstringjava_lang_StringID ,id, title_);
419                         curEnv->DeleteLocalRef(title_);
420 if (curEnv->ExceptionCheck()) {
421 throw GiwsException::JniCallMethodException(curEnv);
422 }
423 }
424
425 void CallScilabBridge::setMessageBoxMessage (JavaVM * jvm_, int id, char const* message){
426
427 JNIEnv * curEnv = NULL;
428 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
429 jclass cls = initClass(curEnv);
430 if ( cls == NULL) {
431 throw GiwsException::JniCallMethodException(curEnv);
432 }
433
434 static jmethodID voidsetMessageBoxMessagejintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setMessageBoxMessage", "(ILjava/lang/String;)V" ) ;
435 if (voidsetMessageBoxMessagejintintjstringjava_lang_StringID == NULL) {
436 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxMessage");
437 }
438
439 jstring message_ = curEnv->NewStringUTF( message );
440 if (message != NULL && message_ == NULL)
441 {
442 throw GiwsException::JniBadAllocException(curEnv);
443 }
444
445
446                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxMessagejintintjstringjava_lang_StringID ,id, message_);
447                         curEnv->DeleteLocalRef(message_);
448 if (curEnv->ExceptionCheck()) {
449 throw GiwsException::JniCallMethodException(curEnv);
450 }
451 }
452
453 void CallScilabBridge::setMessageBoxMessage (JavaVM * jvm_, int id, char const* const* message, int messageSize){
454
455 JNIEnv * curEnv = NULL;
456 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
457 jclass cls = initClass(curEnv);
458 if ( cls == NULL) {
459 throw GiwsException::JniCallMethodException(curEnv);
460 }
461
462 static jmethodID voidsetMessageBoxMessagejintintjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setMessageBoxMessage", "(I[Ljava/lang/String;)V" ) ;
463 if (voidsetMessageBoxMessagejintintjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
464 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxMessage");
465 }
466 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
467
468 // create java array of strings.
469 jobjectArray message_ = curEnv->NewObjectArray( messageSize, stringArrayClass, NULL);
470 if (message_ == NULL)
471 {
472 throw GiwsException::JniBadAllocException(curEnv);
473 }
474
475 // convert each char * to java strings and fill the java array.
476 for ( int i = 0; i < messageSize; i++)
477 {
478 jstring TempString = curEnv->NewStringUTF( message[i] );
479 if (TempString == NULL)
480 {
481 throw GiwsException::JniBadAllocException(curEnv);
482 }
483
484 curEnv->SetObjectArrayElement( message_, i, TempString);
485
486 // avoid keeping reference on too many strings
487 curEnv->DeleteLocalRef(TempString);
488 }
489                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxMessagejintintjobjectArray_java_lang_Stringjava_lang_StringID ,id, message_);
490                         curEnv->DeleteLocalRef(stringArrayClass);
491 curEnv->DeleteLocalRef(message_);
492 if (curEnv->ExceptionCheck()) {
493 throw GiwsException::JniCallMethodException(curEnv);
494 }
495 }
496
497 void CallScilabBridge::messageBoxDisplayAndWait (JavaVM * jvm_, int id){
498
499 JNIEnv * curEnv = NULL;
500 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
501 jclass cls = initClass(curEnv);
502 if ( cls == NULL) {
503 throw GiwsException::JniCallMethodException(curEnv);
504 }
505
506 static jmethodID voidmessageBoxDisplayAndWaitjintintID = curEnv->GetStaticMethodID(cls, "messageBoxDisplayAndWait", "(I)V" ) ;
507 if (voidmessageBoxDisplayAndWaitjintintID == NULL) {
508 throw GiwsException::JniMethodNotFoundException(curEnv, "messageBoxDisplayAndWait");
509 }
510
511                          curEnv->CallStaticVoidMethod(cls, voidmessageBoxDisplayAndWaitjintintID ,id);
512                         if (curEnv->ExceptionCheck()) {
513 throw GiwsException::JniCallMethodException(curEnv);
514 }
515 }
516
517 int CallScilabBridge::getMessageBoxSelectedButton (JavaVM * jvm_, int id){
518
519 JNIEnv * curEnv = NULL;
520 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
521 jclass cls = initClass(curEnv);
522 if ( cls == NULL) {
523 throw GiwsException::JniCallMethodException(curEnv);
524 }
525
526 static jmethodID jintgetMessageBoxSelectedButtonjintintID = curEnv->GetStaticMethodID(cls, "getMessageBoxSelectedButton", "(I)I" ) ;
527 if (jintgetMessageBoxSelectedButtonjintintID == NULL) {
528 throw GiwsException::JniMethodNotFoundException(curEnv, "getMessageBoxSelectedButton");
529 }
530
531                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetMessageBoxSelectedButtonjintintID ,id));
532                         if (curEnv->ExceptionCheck()) {
533 throw GiwsException::JniCallMethodException(curEnv);
534 }
535 return res;
536
537 }
538
539 void CallScilabBridge::setMessageBoxDefaultSelectedButtons (JavaVM * jvm_, int id, int const* index, int indexSize){
540
541 JNIEnv * curEnv = NULL;
542 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
543 jclass cls = initClass(curEnv);
544 if ( cls == NULL) {
545 throw GiwsException::JniCallMethodException(curEnv);
546 }
547
548 static jmethodID voidsetMessageBoxDefaultSelectedButtonsjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "setMessageBoxDefaultSelectedButtons", "(I[I)V" ) ;
549 if (voidsetMessageBoxDefaultSelectedButtonsjintintjintArray_intintID == NULL) {
550 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxDefaultSelectedButtons");
551 }
552
553 jintArray index_ = curEnv->NewIntArray( indexSize ) ;
554
555 if (index_ == NULL)
556 {
557 // check that allocation succeed
558 throw GiwsException::JniBadAllocException(curEnv);
559 }
560
561 curEnv->SetIntArrayRegion( index_, 0, indexSize, (jint*)(index) ) ;
562
563
564                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxDefaultSelectedButtonsjintintjintArray_intintID ,id, index_);
565                         curEnv->DeleteLocalRef(index_);
566 if (curEnv->ExceptionCheck()) {
567 throw GiwsException::JniCallMethodException(curEnv);
568 }
569 }
570
571 int* CallScilabBridge::getMessageBoxUserSelectedButtons (JavaVM * jvm_, int id){
572
573 JNIEnv * curEnv = NULL;
574 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
575 jclass cls = initClass(curEnv);
576 if ( cls == NULL) {
577 throw GiwsException::JniCallMethodException(curEnv);
578 }
579
580 static jmethodID jintArray_getMessageBoxUserSelectedButtonsjintintID = curEnv->GetStaticMethodID(cls, "getMessageBoxUserSelectedButtons", "(I)[I" ) ;
581 if (jintArray_getMessageBoxUserSelectedButtonsjintintID == NULL) {
582 throw GiwsException::JniMethodNotFoundException(curEnv, "getMessageBoxUserSelectedButtons");
583 }
584
585                         jintArray res =  static_cast<jintArray>( curEnv->CallStaticObjectMethod(cls, jintArray_getMessageBoxUserSelectedButtonsjintintID ,id));
586                         if (res == NULL) { return NULL; }
587                         if (curEnv->ExceptionCheck()) {
588 throw GiwsException::JniCallMethodException(curEnv);
589 }int lenRow;
590  lenRow = curEnv->GetArrayLength(res);
591 jboolean isCopy = JNI_FALSE;
592
593 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
594 jint *resultsArray = static_cast<jint *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
595 int* myArray= new int[ lenRow];
596
597 for (jsize i = 0; i <  lenRow; i++){
598 myArray[i]=resultsArray[i];
599 }
600 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
601
602                         curEnv->DeleteLocalRef(res);
603 if (curEnv->ExceptionCheck()) {
604 delete[] myArray;
605                                 throw GiwsException::JniCallMethodException(curEnv);
606 }
607 return myArray;
608
609 }
610
611 void CallScilabBridge::setMessageBoxButtonsLabels (JavaVM * jvm_, int id, char const* const* labels, int labelsSize){
612
613 JNIEnv * curEnv = NULL;
614 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
615 jclass cls = initClass(curEnv);
616 if ( cls == NULL) {
617 throw GiwsException::JniCallMethodException(curEnv);
618 }
619
620 static jmethodID voidsetMessageBoxButtonsLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setMessageBoxButtonsLabels", "(I[Ljava/lang/String;)V" ) ;
621 if (voidsetMessageBoxButtonsLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
622 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxButtonsLabels");
623 }
624 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
625
626 // create java array of strings.
627 jobjectArray labels_ = curEnv->NewObjectArray( labelsSize, stringArrayClass, NULL);
628 if (labels_ == NULL)
629 {
630 throw GiwsException::JniBadAllocException(curEnv);
631 }
632
633 // convert each char * to java strings and fill the java array.
634 for ( int i = 0; i < labelsSize; i++)
635 {
636 jstring TempString = curEnv->NewStringUTF( labels[i] );
637 if (TempString == NULL)
638 {
639 throw GiwsException::JniBadAllocException(curEnv);
640 }
641
642 curEnv->SetObjectArrayElement( labels_, i, TempString);
643
644 // avoid keeping reference on too many strings
645 curEnv->DeleteLocalRef(TempString);
646 }
647                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxButtonsLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID ,id, labels_);
648                         curEnv->DeleteLocalRef(stringArrayClass);
649 curEnv->DeleteLocalRef(labels_);
650 if (curEnv->ExceptionCheck()) {
651 throw GiwsException::JniCallMethodException(curEnv);
652 }
653 }
654
655 void CallScilabBridge::setMessageBoxInitialValue (JavaVM * jvm_, int id, char const* const* value, int valueSize){
656
657 JNIEnv * curEnv = NULL;
658 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
659 jclass cls = initClass(curEnv);
660 if ( cls == NULL) {
661 throw GiwsException::JniCallMethodException(curEnv);
662 }
663
664 static jmethodID voidsetMessageBoxInitialValuejintintjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setMessageBoxInitialValue", "(I[Ljava/lang/String;)V" ) ;
665 if (voidsetMessageBoxInitialValuejintintjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
666 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxInitialValue");
667 }
668 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
669
670 // create java array of strings.
671 jobjectArray value_ = curEnv->NewObjectArray( valueSize, stringArrayClass, NULL);
672 if (value_ == NULL)
673 {
674 throw GiwsException::JniBadAllocException(curEnv);
675 }
676
677 // convert each char * to java strings and fill the java array.
678 for ( int i = 0; i < valueSize; i++)
679 {
680 jstring TempString = curEnv->NewStringUTF( value[i] );
681 if (TempString == NULL)
682 {
683 throw GiwsException::JniBadAllocException(curEnv);
684 }
685
686 curEnv->SetObjectArrayElement( value_, i, TempString);
687
688 // avoid keeping reference on too many strings
689 curEnv->DeleteLocalRef(TempString);
690 }
691                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxInitialValuejintintjobjectArray_java_lang_Stringjava_lang_StringID ,id, value_);
692                         curEnv->DeleteLocalRef(stringArrayClass);
693 curEnv->DeleteLocalRef(value_);
694 if (curEnv->ExceptionCheck()) {
695 throw GiwsException::JniCallMethodException(curEnv);
696 }
697 }
698
699 char** CallScilabBridge::getMessageBoxValue (JavaVM * jvm_, int id){
700
701 JNIEnv * curEnv = NULL;
702 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
703 jclass cls = initClass(curEnv);
704 if ( cls == NULL) {
705 throw GiwsException::JniCallMethodException(curEnv);
706 }
707
708 static jmethodID jobjectArray_getMessageBoxValuejintintID = curEnv->GetStaticMethodID(cls, "getMessageBoxValue", "(I)[Ljava/lang/String;" ) ;
709 if (jobjectArray_getMessageBoxValuejintintID == NULL) {
710 throw GiwsException::JniMethodNotFoundException(curEnv, "getMessageBoxValue");
711 }
712
713                         jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray_getMessageBoxValuejintintID ,id));
714                         if (curEnv->ExceptionCheck()) {
715 throw GiwsException::JniCallMethodException(curEnv);
716 }if (res != NULL) { int lenRow;
717  lenRow = curEnv->GetArrayLength(res);
718
719 char **arrayOfString;
720 arrayOfString = new char *[lenRow];
721 for (jsize i = 0; i < lenRow; i++){
722 jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
723 const char *tempString = curEnv->GetStringUTFChars(resString, 0);
724 arrayOfString[i] = new char[strlen(tempString) + 1];
725
726 strcpy(arrayOfString[i], tempString);
727 curEnv->ReleaseStringUTFChars(resString, tempString);
728 curEnv->DeleteLocalRef(resString);
729 }
730 if (curEnv->ExceptionCheck()) {
731 delete[] arrayOfString;
732                                 throw GiwsException::JniCallMethodException(curEnv);
733 }
734 curEnv->DeleteLocalRef(res);
735 return arrayOfString;
736  } else { 
737 curEnv->DeleteLocalRef(res);
738 return NULL;
739 }
740 }
741
742 int CallScilabBridge::getMessageBoxValueSize (JavaVM * jvm_, int id){
743
744 JNIEnv * curEnv = NULL;
745 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
746 jclass cls = initClass(curEnv);
747 if ( cls == NULL) {
748 throw GiwsException::JniCallMethodException(curEnv);
749 }
750
751 static jmethodID jintgetMessageBoxValueSizejintintID = curEnv->GetStaticMethodID(cls, "getMessageBoxValueSize", "(I)I" ) ;
752 if (jintgetMessageBoxValueSizejintintID == NULL) {
753 throw GiwsException::JniMethodNotFoundException(curEnv, "getMessageBoxValueSize");
754 }
755
756                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetMessageBoxValueSizejintintID ,id));
757                         if (curEnv->ExceptionCheck()) {
758 throw GiwsException::JniCallMethodException(curEnv);
759 }
760 return res;
761
762 }
763
764 void CallScilabBridge::setMessageBoxListBoxItems (JavaVM * jvm_, int id, char const* const* items, int itemsSize){
765
766 JNIEnv * curEnv = NULL;
767 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
768 jclass cls = initClass(curEnv);
769 if ( cls == NULL) {
770 throw GiwsException::JniCallMethodException(curEnv);
771 }
772
773 static jmethodID voidsetMessageBoxListBoxItemsjintintjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setMessageBoxListBoxItems", "(I[Ljava/lang/String;)V" ) ;
774 if (voidsetMessageBoxListBoxItemsjintintjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
775 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxListBoxItems");
776 }
777 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
778
779 // create java array of strings.
780 jobjectArray items_ = curEnv->NewObjectArray( itemsSize, stringArrayClass, NULL);
781 if (items_ == NULL)
782 {
783 throw GiwsException::JniBadAllocException(curEnv);
784 }
785
786 // convert each char * to java strings and fill the java array.
787 for ( int i = 0; i < itemsSize; i++)
788 {
789 jstring TempString = curEnv->NewStringUTF( items[i] );
790 if (TempString == NULL)
791 {
792 throw GiwsException::JniBadAllocException(curEnv);
793 }
794
795 curEnv->SetObjectArrayElement( items_, i, TempString);
796
797 // avoid keeping reference on too many strings
798 curEnv->DeleteLocalRef(TempString);
799 }
800                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxListBoxItemsjintintjobjectArray_java_lang_Stringjava_lang_StringID ,id, items_);
801                         curEnv->DeleteLocalRef(stringArrayClass);
802 curEnv->DeleteLocalRef(items_);
803 if (curEnv->ExceptionCheck()) {
804 throw GiwsException::JniCallMethodException(curEnv);
805 }
806 }
807
808 int CallScilabBridge::getMessageBoxSelectedItem (JavaVM * jvm_, int id){
809
810 JNIEnv * curEnv = NULL;
811 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
812 jclass cls = initClass(curEnv);
813 if ( cls == NULL) {
814 throw GiwsException::JniCallMethodException(curEnv);
815 }
816
817 static jmethodID jintgetMessageBoxSelectedItemjintintID = curEnv->GetStaticMethodID(cls, "getMessageBoxSelectedItem", "(I)I" ) ;
818 if (jintgetMessageBoxSelectedItemjintintID == NULL) {
819 throw GiwsException::JniMethodNotFoundException(curEnv, "getMessageBoxSelectedItem");
820 }
821
822                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetMessageBoxSelectedItemjintintID ,id));
823                         if (curEnv->ExceptionCheck()) {
824 throw GiwsException::JniCallMethodException(curEnv);
825 }
826 return res;
827
828 }
829
830 void CallScilabBridge::setMessageBoxLineLabels (JavaVM * jvm_, int id, char const* const* labels, int labelsSize){
831
832 JNIEnv * curEnv = NULL;
833 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
834 jclass cls = initClass(curEnv);
835 if ( cls == NULL) {
836 throw GiwsException::JniCallMethodException(curEnv);
837 }
838
839 static jmethodID voidsetMessageBoxLineLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setMessageBoxLineLabels", "(I[Ljava/lang/String;)V" ) ;
840 if (voidsetMessageBoxLineLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
841 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxLineLabels");
842 }
843 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
844
845 // create java array of strings.
846 jobjectArray labels_ = curEnv->NewObjectArray( labelsSize, stringArrayClass, NULL);
847 if (labels_ == NULL)
848 {
849 throw GiwsException::JniBadAllocException(curEnv);
850 }
851
852 // convert each char * to java strings and fill the java array.
853 for ( int i = 0; i < labelsSize; i++)
854 {
855 jstring TempString = curEnv->NewStringUTF( labels[i] );
856 if (TempString == NULL)
857 {
858 throw GiwsException::JniBadAllocException(curEnv);
859 }
860
861 curEnv->SetObjectArrayElement( labels_, i, TempString);
862
863 // avoid keeping reference on too many strings
864 curEnv->DeleteLocalRef(TempString);
865 }
866                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxLineLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID ,id, labels_);
867                         curEnv->DeleteLocalRef(stringArrayClass);
868 curEnv->DeleteLocalRef(labels_);
869 if (curEnv->ExceptionCheck()) {
870 throw GiwsException::JniCallMethodException(curEnv);
871 }
872 }
873
874 void CallScilabBridge::setMessageBoxColumnLabels (JavaVM * jvm_, int id, char const* const* labels, int labelsSize){
875
876 JNIEnv * curEnv = NULL;
877 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
878 jclass cls = initClass(curEnv);
879 if ( cls == NULL) {
880 throw GiwsException::JniCallMethodException(curEnv);
881 }
882
883 static jmethodID voidsetMessageBoxColumnLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setMessageBoxColumnLabels", "(I[Ljava/lang/String;)V" ) ;
884 if (voidsetMessageBoxColumnLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
885 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxColumnLabels");
886 }
887 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
888
889 // create java array of strings.
890 jobjectArray labels_ = curEnv->NewObjectArray( labelsSize, stringArrayClass, NULL);
891 if (labels_ == NULL)
892 {
893 throw GiwsException::JniBadAllocException(curEnv);
894 }
895
896 // convert each char * to java strings and fill the java array.
897 for ( int i = 0; i < labelsSize; i++)
898 {
899 jstring TempString = curEnv->NewStringUTF( labels[i] );
900 if (TempString == NULL)
901 {
902 throw GiwsException::JniBadAllocException(curEnv);
903 }
904
905 curEnv->SetObjectArrayElement( labels_, i, TempString);
906
907 // avoid keeping reference on too many strings
908 curEnv->DeleteLocalRef(TempString);
909 }
910                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxColumnLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID ,id, labels_);
911                         curEnv->DeleteLocalRef(stringArrayClass);
912 curEnv->DeleteLocalRef(labels_);
913 if (curEnv->ExceptionCheck()) {
914 throw GiwsException::JniCallMethodException(curEnv);
915 }
916 }
917
918 void CallScilabBridge::setMessageBoxDefaultInput (JavaVM * jvm_, int id, char const* const* values, int valuesSize){
919
920 JNIEnv * curEnv = NULL;
921 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
922 jclass cls = initClass(curEnv);
923 if ( cls == NULL) {
924 throw GiwsException::JniCallMethodException(curEnv);
925 }
926
927 static jmethodID voidsetMessageBoxDefaultInputjintintjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setMessageBoxDefaultInput", "(I[Ljava/lang/String;)V" ) ;
928 if (voidsetMessageBoxDefaultInputjintintjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
929 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxDefaultInput");
930 }
931 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
932
933 // create java array of strings.
934 jobjectArray values_ = curEnv->NewObjectArray( valuesSize, stringArrayClass, NULL);
935 if (values_ == NULL)
936 {
937 throw GiwsException::JniBadAllocException(curEnv);
938 }
939
940 // convert each char * to java strings and fill the java array.
941 for ( int i = 0; i < valuesSize; i++)
942 {
943 jstring TempString = curEnv->NewStringUTF( values[i] );
944 if (TempString == NULL)
945 {
946 throw GiwsException::JniBadAllocException(curEnv);
947 }
948
949 curEnv->SetObjectArrayElement( values_, i, TempString);
950
951 // avoid keeping reference on too many strings
952 curEnv->DeleteLocalRef(TempString);
953 }
954                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxDefaultInputjintintjobjectArray_java_lang_Stringjava_lang_StringID ,id, values_);
955                         curEnv->DeleteLocalRef(stringArrayClass);
956 curEnv->DeleteLocalRef(values_);
957 if (curEnv->ExceptionCheck()) {
958 throw GiwsException::JniCallMethodException(curEnv);
959 }
960 }
961
962 void CallScilabBridge::setMessageBoxModal (JavaVM * jvm_, int id, bool status){
963
964 JNIEnv * curEnv = NULL;
965 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
966 jclass cls = initClass(curEnv);
967 if ( cls == NULL) {
968 throw GiwsException::JniCallMethodException(curEnv);
969 }
970
971 static jmethodID voidsetMessageBoxModaljintintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "setMessageBoxModal", "(IZ)V" ) ;
972 if (voidsetMessageBoxModaljintintjbooleanbooleanID == NULL) {
973 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxModal");
974 }
975
976 jboolean status_ = (static_cast<bool>(status) ? JNI_TRUE : JNI_FALSE);
977
978                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxModaljintintjbooleanbooleanID ,id, status_);
979                         if (curEnv->ExceptionCheck()) {
980 throw GiwsException::JniCallMethodException(curEnv);
981 }
982 }
983
984 void CallScilabBridge::setMessageBoxIcon (JavaVM * jvm_, int id, char const* name){
985
986 JNIEnv * curEnv = NULL;
987 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
988 jclass cls = initClass(curEnv);
989 if ( cls == NULL) {
990 throw GiwsException::JniCallMethodException(curEnv);
991 }
992
993 static jmethodID voidsetMessageBoxIconjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setMessageBoxIcon", "(ILjava/lang/String;)V" ) ;
994 if (voidsetMessageBoxIconjintintjstringjava_lang_StringID == NULL) {
995 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxIcon");
996 }
997
998 jstring name_ = curEnv->NewStringUTF( name );
999 if (name != NULL && name_ == NULL)
1000 {
1001 throw GiwsException::JniBadAllocException(curEnv);
1002 }
1003
1004
1005                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxIconjintintjstringjava_lang_StringID ,id, name_);
1006                         curEnv->DeleteLocalRef(name_);
1007 if (curEnv->ExceptionCheck()) {
1008 throw GiwsException::JniCallMethodException(curEnv);
1009 }
1010 }
1011
1012 void CallScilabBridge::launchHelpBrowser (JavaVM * jvm_, char const* const* helps, int helpsSize, char const* language){
1013
1014 JNIEnv * curEnv = NULL;
1015 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1016 jclass cls = initClass(curEnv);
1017 if ( cls == NULL) {
1018 throw GiwsException::JniCallMethodException(curEnv);
1019 }
1020
1021 static jmethodID voidlaunchHelpBrowserjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "launchHelpBrowser", "([Ljava/lang/String;Ljava/lang/String;)V" ) ;
1022 if (voidlaunchHelpBrowserjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_StringID == NULL) {
1023 throw GiwsException::JniMethodNotFoundException(curEnv, "launchHelpBrowser");
1024 }
1025 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
1026
1027 // create java array of strings.
1028 jobjectArray helps_ = curEnv->NewObjectArray( helpsSize, stringArrayClass, NULL);
1029 if (helps_ == NULL)
1030 {
1031 throw GiwsException::JniBadAllocException(curEnv);
1032 }
1033
1034 // convert each char * to java strings and fill the java array.
1035 for ( int i = 0; i < helpsSize; i++)
1036 {
1037 jstring TempString = curEnv->NewStringUTF( helps[i] );
1038 if (TempString == NULL)
1039 {
1040 throw GiwsException::JniBadAllocException(curEnv);
1041 }
1042
1043 curEnv->SetObjectArrayElement( helps_, i, TempString);
1044
1045 // avoid keeping reference on too many strings
1046 curEnv->DeleteLocalRef(TempString);
1047 }
1048 jstring language_ = curEnv->NewStringUTF( language );
1049 if (language != NULL && language_ == NULL)
1050 {
1051 throw GiwsException::JniBadAllocException(curEnv);
1052 }
1053
1054
1055                          curEnv->CallStaticVoidMethod(cls, voidlaunchHelpBrowserjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_StringID ,helps_, language_);
1056                         curEnv->DeleteLocalRef(stringArrayClass);
1057 curEnv->DeleteLocalRef(helps_);
1058 curEnv->DeleteLocalRef(language_);
1059 if (curEnv->ExceptionCheck()) {
1060 throw GiwsException::JniCallMethodException(curEnv);
1061 }
1062 }
1063
1064 void CallScilabBridge::searchKeyword (JavaVM * jvm_, char const* const* helps, int helpsSize, char const* keyword, char const* language, bool fullText){
1065
1066 JNIEnv * curEnv = NULL;
1067 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1068 jclass cls = initClass(curEnv);
1069 if ( cls == NULL) {
1070 throw GiwsException::JniCallMethodException(curEnv);
1071 }
1072
1073 static jmethodID voidsearchKeywordjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "searchKeyword", "([Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Z)V" ) ;
1074 if (voidsearchKeywordjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID == NULL) {
1075 throw GiwsException::JniMethodNotFoundException(curEnv, "searchKeyword");
1076 }
1077 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
1078
1079 // create java array of strings.
1080 jobjectArray helps_ = curEnv->NewObjectArray( helpsSize, stringArrayClass, NULL);
1081 if (helps_ == NULL)
1082 {
1083 throw GiwsException::JniBadAllocException(curEnv);
1084 }
1085
1086 // convert each char * to java strings and fill the java array.
1087 for ( int i = 0; i < helpsSize; i++)
1088 {
1089 jstring TempString = curEnv->NewStringUTF( helps[i] );
1090 if (TempString == NULL)
1091 {
1092 throw GiwsException::JniBadAllocException(curEnv);
1093 }
1094
1095 curEnv->SetObjectArrayElement( helps_, i, TempString);
1096
1097 // avoid keeping reference on too many strings
1098 curEnv->DeleteLocalRef(TempString);
1099 }
1100 jstring keyword_ = curEnv->NewStringUTF( keyword );
1101 if (keyword != NULL && keyword_ == NULL)
1102 {
1103 throw GiwsException::JniBadAllocException(curEnv);
1104 }
1105
1106
1107 jstring language_ = curEnv->NewStringUTF( language );
1108 if (language != NULL && language_ == NULL)
1109 {
1110 throw GiwsException::JniBadAllocException(curEnv);
1111 }
1112
1113
1114 jboolean fullText_ = (static_cast<bool>(fullText) ? JNI_TRUE : JNI_FALSE);
1115
1116                          curEnv->CallStaticVoidMethod(cls, voidsearchKeywordjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID ,helps_, keyword_, language_, fullText_);
1117                         curEnv->DeleteLocalRef(stringArrayClass);
1118 curEnv->DeleteLocalRef(helps_);
1119 curEnv->DeleteLocalRef(keyword_);
1120 curEnv->DeleteLocalRef(language_);
1121 if (curEnv->ExceptionCheck()) {
1122 throw GiwsException::JniCallMethodException(curEnv);
1123 }
1124 }
1125
1126 int CallScilabBridge::newExportFileChooser (JavaVM * jvm_, int figureUID){
1127
1128 JNIEnv * curEnv = NULL;
1129 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1130 jclass cls = initClass(curEnv);
1131 if ( cls == NULL) {
1132 throw GiwsException::JniCallMethodException(curEnv);
1133 }
1134
1135 static jmethodID jintnewExportFileChooserjintintID = curEnv->GetStaticMethodID(cls, "newExportFileChooser", "(I)I" ) ;
1136 if (jintnewExportFileChooserjintintID == NULL) {
1137 throw GiwsException::JniMethodNotFoundException(curEnv, "newExportFileChooser");
1138 }
1139
1140                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewExportFileChooserjintintID ,figureUID));
1141                         if (curEnv->ExceptionCheck()) {
1142 throw GiwsException::JniCallMethodException(curEnv);
1143 }
1144 return res;
1145
1146 }
1147
1148 int CallScilabBridge::newFontChooser (JavaVM * jvm_){
1149
1150 JNIEnv * curEnv = NULL;
1151 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1152 jclass cls = initClass(curEnv);
1153 if ( cls == NULL) {
1154 throw GiwsException::JniCallMethodException(curEnv);
1155 }
1156
1157 static jmethodID jintnewFontChooserID = curEnv->GetStaticMethodID(cls, "newFontChooser", "()I" ) ;
1158 if (jintnewFontChooserID == NULL) {
1159 throw GiwsException::JniMethodNotFoundException(curEnv, "newFontChooser");
1160 }
1161
1162                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewFontChooserID ));
1163                         if (curEnv->ExceptionCheck()) {
1164 throw GiwsException::JniCallMethodException(curEnv);
1165 }
1166 return res;
1167
1168 }
1169
1170 void CallScilabBridge::fontChooserDisplayAndWait (JavaVM * jvm_, int objID){
1171
1172 JNIEnv * curEnv = NULL;
1173 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1174 jclass cls = initClass(curEnv);
1175 if ( cls == NULL) {
1176 throw GiwsException::JniCallMethodException(curEnv);
1177 }
1178
1179 static jmethodID voidfontChooserDisplayAndWaitjintintID = curEnv->GetStaticMethodID(cls, "fontChooserDisplayAndWait", "(I)V" ) ;
1180 if (voidfontChooserDisplayAndWaitjintintID == NULL) {
1181 throw GiwsException::JniMethodNotFoundException(curEnv, "fontChooserDisplayAndWait");
1182 }
1183
1184                          curEnv->CallStaticVoidMethod(cls, voidfontChooserDisplayAndWaitjintintID ,objID);
1185                         if (curEnv->ExceptionCheck()) {
1186 throw GiwsException::JniCallMethodException(curEnv);
1187 }
1188 }
1189
1190 void CallScilabBridge::setFontChooserFontName (JavaVM * jvm_, int objID, char const* fontName){
1191
1192 JNIEnv * curEnv = NULL;
1193 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1194 jclass cls = initClass(curEnv);
1195 if ( cls == NULL) {
1196 throw GiwsException::JniCallMethodException(curEnv);
1197 }
1198
1199 static jmethodID voidsetFontChooserFontNamejintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setFontChooserFontName", "(ILjava/lang/String;)V" ) ;
1200 if (voidsetFontChooserFontNamejintintjstringjava_lang_StringID == NULL) {
1201 throw GiwsException::JniMethodNotFoundException(curEnv, "setFontChooserFontName");
1202 }
1203
1204 jstring fontName_ = curEnv->NewStringUTF( fontName );
1205 if (fontName != NULL && fontName_ == NULL)
1206 {
1207 throw GiwsException::JniBadAllocException(curEnv);
1208 }
1209
1210
1211                          curEnv->CallStaticVoidMethod(cls, voidsetFontChooserFontNamejintintjstringjava_lang_StringID ,objID, fontName_);
1212                         curEnv->DeleteLocalRef(fontName_);
1213 if (curEnv->ExceptionCheck()) {
1214 throw GiwsException::JniCallMethodException(curEnv);
1215 }
1216 }
1217
1218 void CallScilabBridge::setFontChooserFontSize (JavaVM * jvm_, int objID, int fontSize){
1219
1220 JNIEnv * curEnv = NULL;
1221 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1222 jclass cls = initClass(curEnv);
1223 if ( cls == NULL) {
1224 throw GiwsException::JniCallMethodException(curEnv);
1225 }
1226
1227 static jmethodID voidsetFontChooserFontSizejintintjintintID = curEnv->GetStaticMethodID(cls, "setFontChooserFontSize", "(II)V" ) ;
1228 if (voidsetFontChooserFontSizejintintjintintID == NULL) {
1229 throw GiwsException::JniMethodNotFoundException(curEnv, "setFontChooserFontSize");
1230 }
1231
1232                          curEnv->CallStaticVoidMethod(cls, voidsetFontChooserFontSizejintintjintintID ,objID, fontSize);
1233                         if (curEnv->ExceptionCheck()) {
1234 throw GiwsException::JniCallMethodException(curEnv);
1235 }
1236 }
1237
1238 void CallScilabBridge::setFontChooserBold (JavaVM * jvm_, int objID, bool bold){
1239
1240 JNIEnv * curEnv = NULL;
1241 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1242 jclass cls = initClass(curEnv);
1243 if ( cls == NULL) {
1244 throw GiwsException::JniCallMethodException(curEnv);
1245 }
1246
1247 static jmethodID voidsetFontChooserBoldjintintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "setFontChooserBold", "(IZ)V" ) ;
1248 if (voidsetFontChooserBoldjintintjbooleanbooleanID == NULL) {
1249 throw GiwsException::JniMethodNotFoundException(curEnv, "setFontChooserBold");
1250 }
1251
1252 jboolean bold_ = (static_cast<bool>(bold) ? JNI_TRUE : JNI_FALSE);
1253
1254                          curEnv->CallStaticVoidMethod(cls, voidsetFontChooserBoldjintintjbooleanbooleanID ,objID, bold_);
1255                         if (curEnv->ExceptionCheck()) {
1256 throw GiwsException::JniCallMethodException(curEnv);
1257 }
1258 }
1259
1260 void CallScilabBridge::setFontChooserItalic (JavaVM * jvm_, int objID, bool italic){
1261
1262 JNIEnv * curEnv = NULL;
1263 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1264 jclass cls = initClass(curEnv);
1265 if ( cls == NULL) {
1266 throw GiwsException::JniCallMethodException(curEnv);
1267 }
1268
1269 static jmethodID voidsetFontChooserItalicjintintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "setFontChooserItalic", "(IZ)V" ) ;
1270 if (voidsetFontChooserItalicjintintjbooleanbooleanID == NULL) {
1271 throw GiwsException::JniMethodNotFoundException(curEnv, "setFontChooserItalic");
1272 }
1273
1274 jboolean italic_ = (static_cast<bool>(italic) ? JNI_TRUE : JNI_FALSE);
1275
1276                          curEnv->CallStaticVoidMethod(cls, voidsetFontChooserItalicjintintjbooleanbooleanID ,objID, italic_);
1277                         if (curEnv->ExceptionCheck()) {
1278 throw GiwsException::JniCallMethodException(curEnv);
1279 }
1280 }
1281
1282 char* CallScilabBridge::getFontChooserFontName (JavaVM * jvm_, int objID){
1283
1284 JNIEnv * curEnv = NULL;
1285 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1286 jclass cls = initClass(curEnv);
1287 if ( cls == NULL) {
1288 throw GiwsException::JniCallMethodException(curEnv);
1289 }
1290
1291 static jmethodID jstringgetFontChooserFontNamejintintID = curEnv->GetStaticMethodID(cls, "getFontChooserFontName", "(I)Ljava/lang/String;" ) ;
1292 if (jstringgetFontChooserFontNamejintintID == NULL) {
1293 throw GiwsException::JniMethodNotFoundException(curEnv, "getFontChooserFontName");
1294 }
1295
1296                         jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringgetFontChooserFontNamejintintID ,objID));
1297                         if (curEnv->ExceptionCheck()) {
1298 throw GiwsException::JniCallMethodException(curEnv);
1299 }if (res != NULL) { 
1300
1301 const char *tempString = curEnv->GetStringUTFChars(res, 0);
1302 char * myStringBuffer = new char[strlen(tempString) + 1];
1303 strcpy(myStringBuffer, tempString);
1304 curEnv->ReleaseStringUTFChars(res, tempString);
1305 curEnv->DeleteLocalRef(res);
1306 if (curEnv->ExceptionCheck()) {
1307 delete[] myStringBuffer;
1308                                 throw GiwsException::JniCallMethodException(curEnv);
1309 }
1310 return myStringBuffer;
1311  } else { 
1312 curEnv->DeleteLocalRef(res);
1313 return NULL;
1314 }
1315 }
1316
1317 int CallScilabBridge::getFontChooserFontSize (JavaVM * jvm_, int objID){
1318
1319 JNIEnv * curEnv = NULL;
1320 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1321 jclass cls = initClass(curEnv);
1322 if ( cls == NULL) {
1323 throw GiwsException::JniCallMethodException(curEnv);
1324 }
1325
1326 static jmethodID jintgetFontChooserFontSizejintintID = curEnv->GetStaticMethodID(cls, "getFontChooserFontSize", "(I)I" ) ;
1327 if (jintgetFontChooserFontSizejintintID == NULL) {
1328 throw GiwsException::JniMethodNotFoundException(curEnv, "getFontChooserFontSize");
1329 }
1330
1331                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetFontChooserFontSizejintintID ,objID));
1332                         if (curEnv->ExceptionCheck()) {
1333 throw GiwsException::JniCallMethodException(curEnv);
1334 }
1335 return res;
1336
1337 }
1338
1339 bool CallScilabBridge::getFontChooserBold (JavaVM * jvm_, int objID){
1340
1341 JNIEnv * curEnv = NULL;
1342 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1343 jclass cls = initClass(curEnv);
1344 if ( cls == NULL) {
1345 throw GiwsException::JniCallMethodException(curEnv);
1346 }
1347
1348 static jmethodID jbooleangetFontChooserBoldjintintID = curEnv->GetStaticMethodID(cls, "getFontChooserBold", "(I)Z" ) ;
1349 if (jbooleangetFontChooserBoldjintintID == NULL) {
1350 throw GiwsException::JniMethodNotFoundException(curEnv, "getFontChooserBold");
1351 }
1352
1353                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleangetFontChooserBoldjintintID ,objID));
1354                         if (curEnv->ExceptionCheck()) {
1355 throw GiwsException::JniCallMethodException(curEnv);
1356 }
1357 return (res == JNI_TRUE);
1358
1359 }
1360
1361 bool CallScilabBridge::getFontChooserItalic (JavaVM * jvm_, int objID){
1362
1363 JNIEnv * curEnv = NULL;
1364 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1365 jclass cls = initClass(curEnv);
1366 if ( cls == NULL) {
1367 throw GiwsException::JniCallMethodException(curEnv);
1368 }
1369
1370 static jmethodID jbooleangetFontChooserItalicjintintID = curEnv->GetStaticMethodID(cls, "getFontChooserItalic", "(I)Z" ) ;
1371 if (jbooleangetFontChooserItalicjintintID == NULL) {
1372 throw GiwsException::JniMethodNotFoundException(curEnv, "getFontChooserItalic");
1373 }
1374
1375                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleangetFontChooserItalicjintintID ,objID));
1376                         if (curEnv->ExceptionCheck()) {
1377 throw GiwsException::JniCallMethodException(curEnv);
1378 }
1379 return (res == JNI_TRUE);
1380
1381 }
1382
1383 int CallScilabBridge::newColorChooser (JavaVM * jvm_){
1384
1385 JNIEnv * curEnv = NULL;
1386 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1387 jclass cls = initClass(curEnv);
1388 if ( cls == NULL) {
1389 throw GiwsException::JniCallMethodException(curEnv);
1390 }
1391
1392 static jmethodID jintnewColorChooserID = curEnv->GetStaticMethodID(cls, "newColorChooser", "()I" ) ;
1393 if (jintnewColorChooserID == NULL) {
1394 throw GiwsException::JniMethodNotFoundException(curEnv, "newColorChooser");
1395 }
1396
1397                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewColorChooserID ));
1398                         if (curEnv->ExceptionCheck()) {
1399 throw GiwsException::JniCallMethodException(curEnv);
1400 }
1401 return res;
1402
1403 }
1404
1405 void CallScilabBridge::colorChooserDisplayAndWait (JavaVM * jvm_, int objID){
1406
1407 JNIEnv * curEnv = NULL;
1408 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1409 jclass cls = initClass(curEnv);
1410 if ( cls == NULL) {
1411 throw GiwsException::JniCallMethodException(curEnv);
1412 }
1413
1414 static jmethodID voidcolorChooserDisplayAndWaitjintintID = curEnv->GetStaticMethodID(cls, "colorChooserDisplayAndWait", "(I)V" ) ;
1415 if (voidcolorChooserDisplayAndWaitjintintID == NULL) {
1416 throw GiwsException::JniMethodNotFoundException(curEnv, "colorChooserDisplayAndWait");
1417 }
1418
1419                          curEnv->CallStaticVoidMethod(cls, voidcolorChooserDisplayAndWaitjintintID ,objID);
1420                         if (curEnv->ExceptionCheck()) {
1421 throw GiwsException::JniCallMethodException(curEnv);
1422 }
1423 }
1424
1425 void CallScilabBridge::setColorChooserDefaultColor (JavaVM * jvm_, int objID, int const* rgb, int rgbSize){
1426
1427 JNIEnv * curEnv = NULL;
1428 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1429 jclass cls = initClass(curEnv);
1430 if ( cls == NULL) {
1431 throw GiwsException::JniCallMethodException(curEnv);
1432 }
1433
1434 static jmethodID voidsetColorChooserDefaultColorjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "setColorChooserDefaultColor", "(I[I)V" ) ;
1435 if (voidsetColorChooserDefaultColorjintintjintArray_intintID == NULL) {
1436 throw GiwsException::JniMethodNotFoundException(curEnv, "setColorChooserDefaultColor");
1437 }
1438
1439 jintArray rgb_ = curEnv->NewIntArray( rgbSize ) ;
1440
1441 if (rgb_ == NULL)
1442 {
1443 // check that allocation succeed
1444 throw GiwsException::JniBadAllocException(curEnv);
1445 }
1446
1447 curEnv->SetIntArrayRegion( rgb_, 0, rgbSize, (jint*)(rgb) ) ;
1448
1449
1450                          curEnv->CallStaticVoidMethod(cls, voidsetColorChooserDefaultColorjintintjintArray_intintID ,objID, rgb_);
1451                         curEnv->DeleteLocalRef(rgb_);
1452 if (curEnv->ExceptionCheck()) {
1453 throw GiwsException::JniCallMethodException(curEnv);
1454 }
1455 }
1456
1457 int* CallScilabBridge::getColorChooserSelectedColor (JavaVM * jvm_, int objID){
1458
1459 JNIEnv * curEnv = NULL;
1460 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1461 jclass cls = initClass(curEnv);
1462 if ( cls == NULL) {
1463 throw GiwsException::JniCallMethodException(curEnv);
1464 }
1465
1466 static jmethodID jintArray_getColorChooserSelectedColorjintintID = curEnv->GetStaticMethodID(cls, "getColorChooserSelectedColor", "(I)[I" ) ;
1467 if (jintArray_getColorChooserSelectedColorjintintID == NULL) {
1468 throw GiwsException::JniMethodNotFoundException(curEnv, "getColorChooserSelectedColor");
1469 }
1470
1471                         jintArray res =  static_cast<jintArray>( curEnv->CallStaticObjectMethod(cls, jintArray_getColorChooserSelectedColorjintintID ,objID));
1472                         if (res == NULL) { return NULL; }
1473                         if (curEnv->ExceptionCheck()) {
1474 throw GiwsException::JniCallMethodException(curEnv);
1475 }int lenRow;
1476  lenRow = curEnv->GetArrayLength(res);
1477 jboolean isCopy = JNI_FALSE;
1478
1479 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
1480 jint *resultsArray = static_cast<jint *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
1481 int* myArray= new int[ lenRow];
1482
1483 for (jsize i = 0; i <  lenRow; i++){
1484 myArray[i]=resultsArray[i];
1485 }
1486 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
1487
1488                         curEnv->DeleteLocalRef(res);
1489 if (curEnv->ExceptionCheck()) {
1490 delete[] myArray;
1491                                 throw GiwsException::JniCallMethodException(curEnv);
1492 }
1493 return myArray;
1494
1495 }
1496
1497 void CallScilabBridge::setColorChooserTitle (JavaVM * jvm_, int objID, char const* title){
1498
1499 JNIEnv * curEnv = NULL;
1500 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1501 jclass cls = initClass(curEnv);
1502 if ( cls == NULL) {
1503 throw GiwsException::JniCallMethodException(curEnv);
1504 }
1505
1506 static jmethodID voidsetColorChooserTitlejintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setColorChooserTitle", "(ILjava/lang/String;)V" ) ;
1507 if (voidsetColorChooserTitlejintintjstringjava_lang_StringID == NULL) {
1508 throw GiwsException::JniMethodNotFoundException(curEnv, "setColorChooserTitle");
1509 }
1510
1511 jstring title_ = curEnv->NewStringUTF( title );
1512 if (title != NULL && title_ == NULL)
1513 {
1514 throw GiwsException::JniBadAllocException(curEnv);
1515 }
1516
1517
1518                          curEnv->CallStaticVoidMethod(cls, voidsetColorChooserTitlejintintjstringjava_lang_StringID ,objID, title_);
1519                         curEnv->DeleteLocalRef(title_);
1520 if (curEnv->ExceptionCheck()) {
1521 throw GiwsException::JniCallMethodException(curEnv);
1522 }
1523 }
1524
1525 char* CallScilabBridge::getClipboardContents (JavaVM * jvm_){
1526
1527 JNIEnv * curEnv = NULL;
1528 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1529 jclass cls = initClass(curEnv);
1530 if ( cls == NULL) {
1531 throw GiwsException::JniCallMethodException(curEnv);
1532 }
1533
1534 static jmethodID jstringgetClipboardContentsID = curEnv->GetStaticMethodID(cls, "getClipboardContents", "()Ljava/lang/String;" ) ;
1535 if (jstringgetClipboardContentsID == NULL) {
1536 throw GiwsException::JniMethodNotFoundException(curEnv, "getClipboardContents");
1537 }
1538
1539                         jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringgetClipboardContentsID ));
1540                         if (curEnv->ExceptionCheck()) {
1541 throw GiwsException::JniCallMethodException(curEnv);
1542 }if (res != NULL) { 
1543
1544 const char *tempString = curEnv->GetStringUTFChars(res, 0);
1545 char * myStringBuffer = new char[strlen(tempString) + 1];
1546 strcpy(myStringBuffer, tempString);
1547 curEnv->ReleaseStringUTFChars(res, tempString);
1548 curEnv->DeleteLocalRef(res);
1549 if (curEnv->ExceptionCheck()) {
1550 delete[] myStringBuffer;
1551                                 throw GiwsException::JniCallMethodException(curEnv);
1552 }
1553 return myStringBuffer;
1554  } else { 
1555 curEnv->DeleteLocalRef(res);
1556 return NULL;
1557 }
1558 }
1559
1560 void CallScilabBridge::pasteClipboardIntoConsole (JavaVM * jvm_){
1561
1562 JNIEnv * curEnv = NULL;
1563 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1564 jclass cls = initClass(curEnv);
1565 if ( cls == NULL) {
1566 throw GiwsException::JniCallMethodException(curEnv);
1567 }
1568
1569 static jmethodID voidpasteClipboardIntoConsoleID = curEnv->GetStaticMethodID(cls, "pasteClipboardIntoConsole", "()V" ) ;
1570 if (voidpasteClipboardIntoConsoleID == NULL) {
1571 throw GiwsException::JniMethodNotFoundException(curEnv, "pasteClipboardIntoConsole");
1572 }
1573
1574                          curEnv->CallStaticVoidMethod(cls, voidpasteClipboardIntoConsoleID );
1575                         if (curEnv->ExceptionCheck()) {
1576 throw GiwsException::JniCallMethodException(curEnv);
1577 }
1578 }
1579
1580 void CallScilabBridge::copyConsoleSelection (JavaVM * jvm_){
1581
1582 JNIEnv * curEnv = NULL;
1583 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1584 jclass cls = initClass(curEnv);
1585 if ( cls == NULL) {
1586 throw GiwsException::JniCallMethodException(curEnv);
1587 }
1588
1589 static jmethodID voidcopyConsoleSelectionID = curEnv->GetStaticMethodID(cls, "copyConsoleSelection", "()V" ) ;
1590 if (voidcopyConsoleSelectionID == NULL) {
1591 throw GiwsException::JniMethodNotFoundException(curEnv, "copyConsoleSelection");
1592 }
1593
1594                          curEnv->CallStaticVoidMethod(cls, voidcopyConsoleSelectionID );
1595                         if (curEnv->ExceptionCheck()) {
1596 throw GiwsException::JniCallMethodException(curEnv);
1597 }
1598 }
1599
1600 void CallScilabBridge::emptyClipboard (JavaVM * jvm_){
1601
1602 JNIEnv * curEnv = NULL;
1603 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1604 jclass cls = initClass(curEnv);
1605 if ( cls == NULL) {
1606 throw GiwsException::JniCallMethodException(curEnv);
1607 }
1608
1609 static jmethodID voidemptyClipboardID = curEnv->GetStaticMethodID(cls, "emptyClipboard", "()V" ) ;
1610 if (voidemptyClipboardID == NULL) {
1611 throw GiwsException::JniMethodNotFoundException(curEnv, "emptyClipboard");
1612 }
1613
1614                          curEnv->CallStaticVoidMethod(cls, voidemptyClipboardID );
1615                         if (curEnv->ExceptionCheck()) {
1616 throw GiwsException::JniCallMethodException(curEnv);
1617 }
1618 }
1619
1620 void CallScilabBridge::setClipboardContents (JavaVM * jvm_, char const* text){
1621
1622 JNIEnv * curEnv = NULL;
1623 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1624 jclass cls = initClass(curEnv);
1625 if ( cls == NULL) {
1626 throw GiwsException::JniCallMethodException(curEnv);
1627 }
1628
1629 static jmethodID voidsetClipboardContentsjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setClipboardContents", "(Ljava/lang/String;)V" ) ;
1630 if (voidsetClipboardContentsjstringjava_lang_StringID == NULL) {
1631 throw GiwsException::JniMethodNotFoundException(curEnv, "setClipboardContents");
1632 }
1633
1634 jstring text_ = curEnv->NewStringUTF( text );
1635 if (text != NULL && text_ == NULL)
1636 {
1637 throw GiwsException::JniBadAllocException(curEnv);
1638 }
1639
1640
1641                          curEnv->CallStaticVoidMethod(cls, voidsetClipboardContentsjstringjava_lang_StringID ,text_);
1642                         curEnv->DeleteLocalRef(text_);
1643 if (curEnv->ExceptionCheck()) {
1644 throw GiwsException::JniCallMethodException(curEnv);
1645 }
1646 }
1647
1648 void CallScilabBridge::copyFigureToClipBoard (JavaVM * jvm_, int figID){
1649
1650 JNIEnv * curEnv = NULL;
1651 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1652 jclass cls = initClass(curEnv);
1653 if ( cls == NULL) {
1654 throw GiwsException::JniCallMethodException(curEnv);
1655 }
1656
1657 static jmethodID voidcopyFigureToClipBoardjintintID = curEnv->GetStaticMethodID(cls, "copyFigureToClipBoard", "(I)V" ) ;
1658 if (voidcopyFigureToClipBoardjintintID == NULL) {
1659 throw GiwsException::JniMethodNotFoundException(curEnv, "copyFigureToClipBoard");
1660 }
1661
1662                          curEnv->CallStaticVoidMethod(cls, voidcopyFigureToClipBoardjintintID ,figID);
1663                         if (curEnv->ExceptionCheck()) {
1664 throw GiwsException::JniCallMethodException(curEnv);
1665 }
1666 }
1667
1668 int CallScilabBridge::getScreenResolution (JavaVM * jvm_){
1669
1670 JNIEnv * curEnv = NULL;
1671 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1672 jclass cls = initClass(curEnv);
1673 if ( cls == NULL) {
1674 throw GiwsException::JniCallMethodException(curEnv);
1675 }
1676
1677 static jmethodID jintgetScreenResolutionID = curEnv->GetStaticMethodID(cls, "getScreenResolution", "()I" ) ;
1678 if (jintgetScreenResolutionID == NULL) {
1679 throw GiwsException::JniMethodNotFoundException(curEnv, "getScreenResolution");
1680 }
1681
1682                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetScreenResolutionID ));
1683                         if (curEnv->ExceptionCheck()) {
1684 throw GiwsException::JniCallMethodException(curEnv);
1685 }
1686 return res;
1687
1688 }
1689
1690 double CallScilabBridge::getScreenWidth (JavaVM * jvm_){
1691
1692 JNIEnv * curEnv = NULL;
1693 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1694 jclass cls = initClass(curEnv);
1695 if ( cls == NULL) {
1696 throw GiwsException::JniCallMethodException(curEnv);
1697 }
1698
1699 static jmethodID jdoublegetScreenWidthID = curEnv->GetStaticMethodID(cls, "getScreenWidth", "()D" ) ;
1700 if (jdoublegetScreenWidthID == NULL) {
1701 throw GiwsException::JniMethodNotFoundException(curEnv, "getScreenWidth");
1702 }
1703
1704                         jdouble res =  static_cast<jdouble>( curEnv->CallStaticDoubleMethod(cls, jdoublegetScreenWidthID ));
1705                         if (curEnv->ExceptionCheck()) {
1706 throw GiwsException::JniCallMethodException(curEnv);
1707 }
1708 return res;
1709
1710 }
1711
1712 double CallScilabBridge::getScreenHeight (JavaVM * jvm_){
1713
1714 JNIEnv * curEnv = NULL;
1715 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1716 jclass cls = initClass(curEnv);
1717 if ( cls == NULL) {
1718 throw GiwsException::JniCallMethodException(curEnv);
1719 }
1720
1721 static jmethodID jdoublegetScreenHeightID = curEnv->GetStaticMethodID(cls, "getScreenHeight", "()D" ) ;
1722 if (jdoublegetScreenHeightID == NULL) {
1723 throw GiwsException::JniMethodNotFoundException(curEnv, "getScreenHeight");
1724 }
1725
1726                         jdouble res =  static_cast<jdouble>( curEnv->CallStaticDoubleMethod(cls, jdoublegetScreenHeightID ));
1727                         if (curEnv->ExceptionCheck()) {
1728 throw GiwsException::JniCallMethodException(curEnv);
1729 }
1730 return res;
1731
1732 }
1733
1734 int CallScilabBridge::getScreenDepth (JavaVM * jvm_){
1735
1736 JNIEnv * curEnv = NULL;
1737 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1738 jclass cls = initClass(curEnv);
1739 if ( cls == NULL) {
1740 throw GiwsException::JniCallMethodException(curEnv);
1741 }
1742
1743 static jmethodID jintgetScreenDepthID = curEnv->GetStaticMethodID(cls, "getScreenDepth", "()I" ) ;
1744 if (jintgetScreenDepthID == NULL) {
1745 throw GiwsException::JniMethodNotFoundException(curEnv, "getScreenDepth");
1746 }
1747
1748                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetScreenDepthID ));
1749                         if (curEnv->ExceptionCheck()) {
1750 throw GiwsException::JniCallMethodException(curEnv);
1751 }
1752 return res;
1753
1754 }
1755
1756 bool CallScilabBridge::printFigure (JavaVM * jvm_, int figID, bool postScript, bool displayDialog){
1757
1758 JNIEnv * curEnv = NULL;
1759 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1760 jclass cls = initClass(curEnv);
1761 if ( cls == NULL) {
1762 throw GiwsException::JniCallMethodException(curEnv);
1763 }
1764
1765 static jmethodID jbooleanprintFigurejintintjbooleanbooleanjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "printFigure", "(IZZ)Z" ) ;
1766 if (jbooleanprintFigurejintintjbooleanbooleanjbooleanbooleanID == NULL) {
1767 throw GiwsException::JniMethodNotFoundException(curEnv, "printFigure");
1768 }
1769
1770 jboolean postScript_ = (static_cast<bool>(postScript) ? JNI_TRUE : JNI_FALSE);
1771
1772 jboolean displayDialog_ = (static_cast<bool>(displayDialog) ? JNI_TRUE : JNI_FALSE);
1773
1774                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanprintFigurejintintjbooleanbooleanjbooleanbooleanID ,figID, postScript_, displayDialog_));
1775                         if (curEnv->ExceptionCheck()) {
1776 throw GiwsException::JniCallMethodException(curEnv);
1777 }
1778 return (res == JNI_TRUE);
1779
1780 }
1781
1782 bool CallScilabBridge::printFile (JavaVM * jvm_, char const* fileName){
1783
1784 JNIEnv * curEnv = NULL;
1785 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1786 jclass cls = initClass(curEnv);
1787 if ( cls == NULL) {
1788 throw GiwsException::JniCallMethodException(curEnv);
1789 }
1790
1791 static jmethodID jbooleanprintFilejstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "printFile", "(Ljava/lang/String;)Z" ) ;
1792 if (jbooleanprintFilejstringjava_lang_StringID == NULL) {
1793 throw GiwsException::JniMethodNotFoundException(curEnv, "printFile");
1794 }
1795
1796 jstring fileName_ = curEnv->NewStringUTF( fileName );
1797 if (fileName != NULL && fileName_ == NULL)
1798 {
1799 throw GiwsException::JniBadAllocException(curEnv);
1800 }
1801
1802
1803                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanprintFilejstringjava_lang_StringID ,fileName_));
1804                         curEnv->DeleteLocalRef(fileName_);
1805 if (curEnv->ExceptionCheck()) {
1806 throw GiwsException::JniCallMethodException(curEnv);
1807 }
1808 return (res == JNI_TRUE);
1809
1810 }
1811
1812 bool CallScilabBridge::printString (JavaVM * jvm_, char const* theString, char const* pageHeader){
1813
1814 JNIEnv * curEnv = NULL;
1815 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1816 jclass cls = initClass(curEnv);
1817 if ( cls == NULL) {
1818 throw GiwsException::JniCallMethodException(curEnv);
1819 }
1820
1821 static jmethodID jbooleanprintStringjstringjava_lang_Stringjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "printString", "(Ljava/lang/String;Ljava/lang/String;)Z" ) ;
1822 if (jbooleanprintStringjstringjava_lang_Stringjstringjava_lang_StringID == NULL) {
1823 throw GiwsException::JniMethodNotFoundException(curEnv, "printString");
1824 }
1825
1826 jstring theString_ = curEnv->NewStringUTF( theString );
1827 if (theString != NULL && theString_ == NULL)
1828 {
1829 throw GiwsException::JniBadAllocException(curEnv);
1830 }
1831
1832
1833 jstring pageHeader_ = curEnv->NewStringUTF( pageHeader );
1834 if (pageHeader != NULL && pageHeader_ == NULL)
1835 {
1836 throw GiwsException::JniBadAllocException(curEnv);
1837 }
1838
1839
1840                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanprintStringjstringjava_lang_Stringjstringjava_lang_StringID ,theString_, pageHeader_));
1841                         curEnv->DeleteLocalRef(theString_);
1842 curEnv->DeleteLocalRef(pageHeader_);
1843 if (curEnv->ExceptionCheck()) {
1844 throw GiwsException::JniCallMethodException(curEnv);
1845 }
1846 return (res == JNI_TRUE);
1847
1848 }
1849
1850 bool CallScilabBridge::pageSetup (JavaVM * jvm_){
1851
1852 JNIEnv * curEnv = NULL;
1853 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1854 jclass cls = initClass(curEnv);
1855 if ( cls == NULL) {
1856 throw GiwsException::JniCallMethodException(curEnv);
1857 }
1858
1859 static jmethodID jbooleanpageSetupID = curEnv->GetStaticMethodID(cls, "pageSetup", "()Z" ) ;
1860 if (jbooleanpageSetupID == NULL) {
1861 throw GiwsException::JniMethodNotFoundException(curEnv, "pageSetup");
1862 }
1863
1864                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanpageSetupID ));
1865                         if (curEnv->ExceptionCheck()) {
1866 throw GiwsException::JniCallMethodException(curEnv);
1867 }
1868 return (res == JNI_TRUE);
1869
1870 }
1871
1872 void CallScilabBridge::requestFocus (JavaVM * jvm_, int objUID){
1873
1874 JNIEnv * curEnv = NULL;
1875 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1876 jclass cls = initClass(curEnv);
1877 if ( cls == NULL) {
1878 throw GiwsException::JniCallMethodException(curEnv);
1879 }
1880
1881 static jmethodID voidrequestFocusjintintID = curEnv->GetStaticMethodID(cls, "requestFocus", "(I)V" ) ;
1882 if (voidrequestFocusjintintID == NULL) {
1883 throw GiwsException::JniMethodNotFoundException(curEnv, "requestFocus");
1884 }
1885
1886                          curEnv->CallStaticVoidMethod(cls, voidrequestFocusjintintID ,objUID);
1887                         if (curEnv->ExceptionCheck()) {
1888 throw GiwsException::JniCallMethodException(curEnv);
1889 }
1890 }
1891
1892 void CallScilabBridge::raiseWindow (JavaVM * jvm_, int objID){
1893
1894 JNIEnv * curEnv = NULL;
1895 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1896 jclass cls = initClass(curEnv);
1897 if ( cls == NULL) {
1898 throw GiwsException::JniCallMethodException(curEnv);
1899 }
1900
1901 static jmethodID voidraiseWindowjintintID = curEnv->GetStaticMethodID(cls, "raiseWindow", "(I)V" ) ;
1902 if (voidraiseWindowjintintID == NULL) {
1903 throw GiwsException::JniMethodNotFoundException(curEnv, "raiseWindow");
1904 }
1905
1906                          curEnv->CallStaticVoidMethod(cls, voidraiseWindowjintintID ,objID);
1907                         if (curEnv->ExceptionCheck()) {
1908 throw GiwsException::JniCallMethodException(curEnv);
1909 }
1910 }
1911
1912 void CallScilabBridge::useCanvasForDisplay (JavaVM * jvm_, bool onOrOff){
1913
1914 JNIEnv * curEnv = NULL;
1915 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1916 jclass cls = initClass(curEnv);
1917 if ( cls == NULL) {
1918 throw GiwsException::JniCallMethodException(curEnv);
1919 }
1920
1921 static jmethodID voiduseCanvasForDisplayjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "useCanvasForDisplay", "(Z)V" ) ;
1922 if (voiduseCanvasForDisplayjbooleanbooleanID == NULL) {
1923 throw GiwsException::JniMethodNotFoundException(curEnv, "useCanvasForDisplay");
1924 }
1925
1926 jboolean onOrOff_ = (static_cast<bool>(onOrOff) ? JNI_TRUE : JNI_FALSE);
1927
1928                          curEnv->CallStaticVoidMethod(cls, voiduseCanvasForDisplayjbooleanbooleanID ,onOrOff_);
1929                         if (curEnv->ExceptionCheck()) {
1930 throw GiwsException::JniCallMethodException(curEnv);
1931 }
1932 }
1933
1934 bool CallScilabBridge::useCanvasForDisplay (JavaVM * jvm_){
1935
1936 JNIEnv * curEnv = NULL;
1937 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1938 jclass cls = initClass(curEnv);
1939 if ( cls == NULL) {
1940 throw GiwsException::JniCallMethodException(curEnv);
1941 }
1942
1943 static jmethodID jbooleanuseCanvasForDisplayID = curEnv->GetStaticMethodID(cls, "useCanvasForDisplay", "()Z" ) ;
1944 if (jbooleanuseCanvasForDisplayID == NULL) {
1945 throw GiwsException::JniMethodNotFoundException(curEnv, "useCanvasForDisplay");
1946 }
1947
1948                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanuseCanvasForDisplayID ));
1949                         if (curEnv->ExceptionCheck()) {
1950 throw GiwsException::JniCallMethodException(curEnv);
1951 }
1952 return (res == JNI_TRUE);
1953
1954 }
1955
1956 void CallScilabBridge::scilabAboutBox (JavaVM * jvm_){
1957
1958 JNIEnv * curEnv = NULL;
1959 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1960 jclass cls = initClass(curEnv);
1961 if ( cls == NULL) {
1962 throw GiwsException::JniCallMethodException(curEnv);
1963 }
1964
1965 static jmethodID voidscilabAboutBoxID = curEnv->GetStaticMethodID(cls, "scilabAboutBox", "()V" ) ;
1966 if (voidscilabAboutBoxID == NULL) {
1967 throw GiwsException::JniMethodNotFoundException(curEnv, "scilabAboutBox");
1968 }
1969
1970                          curEnv->CallStaticVoidMethod(cls, voidscilabAboutBoxID );
1971                         if (curEnv->ExceptionCheck()) {
1972 throw GiwsException::JniCallMethodException(curEnv);
1973 }
1974 }
1975
1976 void CallScilabBridge::fireClosingFinished (JavaVM * jvm_, int figUID){
1977
1978 JNIEnv * curEnv = NULL;
1979 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1980 jclass cls = initClass(curEnv);
1981 if ( cls == NULL) {
1982 throw GiwsException::JniCallMethodException(curEnv);
1983 }
1984
1985 static jmethodID voidfireClosingFinishedjintintID = curEnv->GetStaticMethodID(cls, "fireClosingFinished", "(I)V" ) ;
1986 if (voidfireClosingFinishedjintintID == NULL) {
1987 throw GiwsException::JniMethodNotFoundException(curEnv, "fireClosingFinished");
1988 }
1989
1990                          curEnv->CallStaticVoidMethod(cls, voidfireClosingFinishedjintintID ,figUID);
1991                         if (curEnv->ExceptionCheck()) {
1992 throw GiwsException::JniCallMethodException(curEnv);
1993 }
1994 }
1995
1996 }