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