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