* Rename style 'ImageRenderer' to 'Image'
[scilab.git] / scilab / modules / gui / src / jni / CallScilabBridge.cpp
1 #include "CallScilabBridge.hxx"
2 /* Generated by GIWS (version 2.0.0) with command:
3 giws --disable-return-size-array --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/CallScilabBridge.giws.xml 
4 */
5 /*
6
7 Copyright 2007-2008 INRIA
8 Copyright 2008-2011 DIGITEO
9 Copyright 2011-2012 Scilab Enterprises
10
11 Author : Sylvestre Ledru & others
12
13 This is generated code.
14
15 This software is a computer program whose purpose is to hide the complexity
16 of accessing Java objects/methods from C++ code.
17
18 This software is governed by the CeCILL-B license under French law and
19 abiding by the rules of distribution of free software.  You can  use, 
20 modify and/ or redistribute the software under the terms of the CeCILL-B
21 license as circulated by CEA, CNRS and INRIA at the following URL
22 "http://www.cecill.info". 
23
24 As a counterpart to the access to the source code and  rights to copy,
25 modify and redistribute granted by the license, users are provided only
26 with a limited warranty  and the software's author,  the holder of the
27 economic rights,  and the successive licensors  have only  limited
28 liability. 
29
30 In this respect, the user's attention is drawn to the risks associated
31 with loading,  using,  modifying and/or developing or reproducing the
32 software by the user in light of its specific status of free software,
33 that may mean  that it is complicated to manipulate,  and  that  also
34 therefore means  that it is reserved for developers  and  experienced
35 professionals having in-depth computer knowledge. Users are therefore
36 encouraged to load and test the software's suitability as regards their
37 requirements in conditions enabling the security of their systems and/or 
38 data to be ensured and,  more generally, to use and operate it in the 
39 same conditions as regards security. 
40
41 The fact that you are presently reading this means that you have had
42 knowledge of the CeCILL-B license and that you accept its terms.
43 */
44
45 namespace org_scilab_modules_gui_bridge {
46
47                 // Static declarations (if any)
48                 
49 // Returns the current env
50
51 JNIEnv * CallScilabBridge::getCurrentEnv() {
52 JNIEnv * curEnv = NULL;
53 jint res=this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
54 if (res != JNI_OK) {
55 throw GiwsException::JniException(getCurrentEnv());
56 }
57 return curEnv;
58 }
59 // Destructor
60
61 CallScilabBridge::~CallScilabBridge() {
62 JNIEnv * curEnv = NULL;
63 this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
64
65 curEnv->DeleteGlobalRef(this->instance);
66 curEnv->DeleteGlobalRef(this->instanceClass);
67 curEnv->DeleteGlobalRef(this->stringArrayClass);}
68 // Constructors
69 CallScilabBridge::CallScilabBridge(JavaVM * jvm_) {
70 jmethodID constructObject = NULL ;
71 jobject localInstance ;
72 jclass localClass ;
73
74 const std::string construct="<init>";
75 const std::string param="()V";
76 jvm=jvm_;
77
78 JNIEnv * curEnv = getCurrentEnv();
79
80 localClass = curEnv->FindClass( this->className().c_str() ) ;
81 if (localClass == NULL) {
82   throw GiwsException::JniClassNotFoundException(curEnv, this->className());
83 }
84
85 this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
86
87 /* localClass is not needed anymore */
88 curEnv->DeleteLocalRef(localClass);
89
90 if (this->instanceClass == NULL) {
91 throw GiwsException::JniObjectCreationException(curEnv, this->className());
92 }
93
94
95 constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
96 if(constructObject == NULL){
97 throw GiwsException::JniObjectCreationException(curEnv, this->className());
98 }
99
100 localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
101 if(localInstance == NULL){
102 throw GiwsException::JniObjectCreationException(curEnv, this->className());
103 }
104  
105 this->instance = curEnv->NewGlobalRef(localInstance) ;
106 if(this->instance == NULL){
107 throw GiwsException::JniObjectCreationException(curEnv, this->className());
108 }
109 /* localInstance not needed anymore */
110 curEnv->DeleteLocalRef(localInstance);
111
112                 /* Methods ID set to NULL */
113 jintnewWindowID=NULL;
114 jintnewMenuBarID=NULL;
115 jintnewMenuID=NULL;
116 jintnewPushButtonID=NULL;
117 jintnewPushButtonjstringjava_lang_StringID=NULL;
118 jintnewEditBoxID=NULL;
119 jintnewLabelID=NULL;
120 jintnewCheckBoxID=NULL;
121 jintnewRadioButtonID=NULL;
122 jintnewSliderID=NULL;
123 jintnewPopupMenuID=NULL;
124 jintnewListBoxID=NULL;
125 jintnewFrameID=NULL;
126 jintnewUiTableID=NULL;
127 jintnewUiDisplayTreeID=NULL;
128 jstringnewContextMenujobjectArray_java_lang_Stringjava_lang_StringID=NULL;
129 jintnewContextMenuID=NULL;
130 voiddestroyWidgetjintintID=NULL;
131 voiddestroyFramejintintID=NULL;
132 jintnewWindowjintintID=NULL;
133 voidsetFigureAsParentjintintjintintID=NULL;
134 voidsetMenuAsParentjintintjintintID=NULL;
135 voidsetRootAsParentjintintID=NULL;
136 voidsetParentjintintjintintID=NULL;
137 voidsetPushButtonParentjintintjintintID=NULL;
138 voidremovePushButtonFromParentjintintjintintID=NULL;
139 voidsetEditBoxParentjintintjintintID=NULL;
140 voidremoveEditBoxFromParentjintintjintintID=NULL;
141 voidsetLabelParentjintintjintintID=NULL;
142 voidremoveLabelFromParentjintintjintintID=NULL;
143 voidsetCheckBoxParentjintintjintintID=NULL;
144 voidremoveCheckBoxFromParentjintintjintintID=NULL;
145 voidsetRadioButtonParentjintintjintintID=NULL;
146 voidremoveRadioButtonFromParentjintintjintintID=NULL;
147 voidsetUiTableParentjintintjintintID=NULL;
148 voidremoveUiTableFromParentjintintjintintID=NULL;
149 voidsetUiDisplayTreeParentjintintjintintID=NULL;
150 voidremoveUiDisplayTreeFromParentjintintjintintID=NULL;
151 voidsetSliderParentjintintjintintID=NULL;
152 voidremoveSliderFromParentjintintjintintID=NULL;
153 voidsetPopupMenuParentjintintjintintID=NULL;
154 voidremovePopupMenuFromParentjintintjintintID=NULL;
155 voidsetListBoxParentjintintjintintID=NULL;
156 voidremoveListBoxFromParentjintintjintintID=NULL;
157 voidsetFrameParentjintintjintintID=NULL;
158 voidremoveFrameFromParentjintintjintintID=NULL;
159 voidsetWidgetTextjintintjstringjava_lang_StringID=NULL;
160 jstringgetWidgetTextjintintID=NULL;
161 voidsetFrameTextjintintjstringjava_lang_StringID=NULL;
162 jstringgetFrameTextjintintID=NULL;
163 voidsetWidgetBackgroundColorjintintjintintjintintjintintID=NULL;
164 jintArray_getWidgetBackgroundColorjintintID=NULL;
165 voidsetWidgetForegroundColorjintintjintintjintintjintintID=NULL;
166 jintArray_getWidgetForegroundColorjintintID=NULL;
167 voidsetFrameBackgroundColorjintintjintintjintintjintintID=NULL;
168 jintArray_getFrameBackgroundColorjintintID=NULL;
169 voidsetFrameForegroundColorjintintjintintjintintjintintID=NULL;
170 jintArray_getFrameForegroundColorjintintID=NULL;
171 voidsetWidgetFontNamejintintjstringjava_lang_StringID=NULL;
172 jstringgetWidgetFontNamejintintID=NULL;
173 voidsetWidgetFontWeightjintintjstringjava_lang_StringID=NULL;
174 voidsetWidgetFontSizejintintjintintID=NULL;
175 jintgetWidgetFontSizejintintID=NULL;
176 voidsetWidgetFontAnglejintintjstringjava_lang_StringID=NULL;
177 voidsetFrameFontNamejintintjstringjava_lang_StringID=NULL;
178 jstringgetFrameFontNamejintintID=NULL;
179 voidsetFrameFontWeightjintintjstringjava_lang_StringID=NULL;
180 voidsetFrameFontSizejintintjintintID=NULL;
181 jintgetFrameFontSizejintintID=NULL;
182 voidsetFrameFontAnglejintintjstringjava_lang_StringID=NULL;
183 voidsetWidgetPositionjintintjintintjintintjintintjintintID=NULL;
184 jintArray_getWidgetPositionjintintID=NULL;
185 voidsetFramePositionjintintjintintjintintjintintjintintID=NULL;
186 jintArray_getFramePositionjintintID=NULL;
187 voidsetWidgetCallbackjintintjstringjava_lang_StringjintintID=NULL;
188 voidsetFrameCallbackjintintjstringjava_lang_StringjintintID=NULL;
189 voidsetWidgetHorizontalAlignmentjintintjstringjava_lang_StringID=NULL;
190 voidsetWidgetVerticalAlignmentjintintjstringjava_lang_StringID=NULL;
191 voidsetSliderMinorTickSpacingjintintjintintID=NULL;
192 voidsetSliderMajorTickSpacingjintintjintintID=NULL;
193 voidsetListBoxSelectedIndicesjintintjintArray_intintID=NULL;
194 jintArray_getListBoxSelectedIndicesjintintID=NULL;
195 jintgetListBoxSelectionSizejintintID=NULL;
196 voidsetPopupMenuSelectedIndexjintintjintintID=NULL;
197 jintgetPopupMenuSelectedIndexjintintID=NULL;
198 voidsetSliderValuejintintjintintID=NULL;
199 jintgetSliderValuejintintID=NULL;
200 voidsetRadioButtonCheckedjintintjbooleanbooleanID=NULL;
201 jbooleanisRadioButtonCheckedjintintID=NULL;
202 voidsetCheckBoxCheckedjintintjbooleanbooleanID=NULL;
203 jbooleanisCheckBoxCheckedjintintID=NULL;
204 voidsetSliderMinValuejintintjintintID=NULL;
205 voidsetSliderMaxValuejintintjintintID=NULL;
206 voidsetSliderVerticaljintintID=NULL;
207 voidsetSliderHorizontaljintintID=NULL;
208 voidsetListBoxMultipleSelectionEnabledjintintjbooleanbooleanID=NULL;
209 jobjectArray_getListBoxAllItemsTextjintintID=NULL;
210 jintgetListBoxNumberOfItemsjintintID=NULL;
211 voidsetListBoxTextjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
212 voidsetListBoxListBoxTopjintintjintintID=NULL;
213 jintgetListBoxListBoxTopjintintID=NULL;
214 jobjectArray_getPopupMenuAllItemsTextjintintID=NULL;
215 jintgetPopupMenuNumberOfItemsjintintID=NULL;
216 voidsetPopupMenuTextjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
217 voidsetWidgetReliefjintintjstringjava_lang_StringID=NULL;
218 voidsetFrameReliefjintintjstringjava_lang_StringID=NULL;
219 voidsetMenuEnabledjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID=NULL;
220 voidsetSubMenuEnabledjstringjava_lang_Stringjstringjava_lang_StringjintintjbooleanbooleanID=NULL;
221 voidsetWidgetEnablejintintjbooleanbooleanID=NULL;
222 voidsetFrameEnablejintintjbooleanbooleanID=NULL;
223 jbooleanisWidgetEnablejintintID=NULL;
224 jbooleanisFrameEnablejintintID=NULL;
225 voidsetMenuCheckedjintintjbooleanbooleanID=NULL;
226 jbooleanisMenuCheckedjintintID=NULL;
227 voidremoveMenujstringjava_lang_Stringjstringjava_lang_StringID=NULL;
228 jstringdisplayAndWaitContextMenujstringjava_lang_StringID=NULL;
229 jintnewMessageBoxID=NULL;
230 voidsetMessageBoxTitlejintintjstringjava_lang_StringID=NULL;
231 voidsetMessageBoxMessagejintintjstringjava_lang_StringID=NULL;
232 voidsetMessageBoxMessagejintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
233 voidmessageBoxDisplayAndWaitjintintID=NULL;
234 jintgetMessageBoxSelectedButtonjintintID=NULL;
235 voidsetMessageBoxDefaultSelectedButtonsjintintjintArray_intintID=NULL;
236 jintArray_getMessageBoxUserSelectedButtonsjintintID=NULL;
237 voidsetMessageBoxButtonsLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
238 voidsetMessageBoxInitialValuejintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
239 jobjectArray_getMessageBoxValuejintintID=NULL;
240 jintgetMessageBoxValueSizejintintID=NULL;
241 voidsetMessageBoxListBoxItemsjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
242 jintgetMessageBoxSelectedItemjintintID=NULL;
243 voidsetMessageBoxLineLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
244 voidsetMessageBoxColumnLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
245 voidsetMessageBoxDefaultInputjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
246 voidsetMessageBoxModaljintintjbooleanbooleanID=NULL;
247 voidsetMessageBoxIconjintintjstringjava_lang_StringID=NULL;
248 jbooleanisToolbarVisiblejstringjava_lang_StringID=NULL;
249 voidsetToolbarVisiblejstringjava_lang_StringjbooleanbooleanID=NULL;
250 voidsetEventHandlerjintintjstringjava_lang_StringID=NULL;
251 voidsetEventHandlerEnabledjintintjbooleanbooleanID=NULL;
252 jintnewWaitBarID=NULL;
253 voidsetWaitBarMessagejintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
254 voidsetWaitBarValuejintintjintintID=NULL;
255 voiddestroyWaitBarjintintID=NULL;
256 voidsetWaitBarIndeterminateModejintintjbooleanbooleanID=NULL;
257 voidlaunchHelpBrowserjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_StringID=NULL;
258 voidsearchKeywordjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID=NULL;
259 jintnewExportFileChooserjintintID=NULL;
260 jintnewFontChooserID=NULL;
261 voidfontChooserDisplayAndWaitjintintID=NULL;
262 voidsetFontChooserFontNamejintintjstringjava_lang_StringID=NULL;
263 voidsetFontChooserFontSizejintintjintintID=NULL;
264 voidsetFontChooserBoldjintintjbooleanbooleanID=NULL;
265 voidsetFontChooserItalicjintintjbooleanbooleanID=NULL;
266 jstringgetFontChooserFontNamejintintID=NULL;
267 jintgetFontChooserFontSizejintintID=NULL;
268 jbooleangetFontChooserBoldjintintID=NULL;
269 jbooleangetFontChooserItalicjintintID=NULL;
270 jintnewColorChooserID=NULL;
271 voidcolorChooserDisplayAndWaitjintintID=NULL;
272 voidsetColorChooserDefaultColorjintintjintArray_intintID=NULL;
273 jintArray_getColorChooserSelectedColorjintintID=NULL;
274 voidsetColorChooserTitlejintintjstringjava_lang_StringID=NULL;
275 voidsetWidgetVisiblejintintjbooleanbooleanID=NULL;
276 voidsetFrameVisiblejintintjbooleanbooleanID=NULL;
277 jbooleanisWidgetVisiblejintintID=NULL;
278 jbooleanisFrameVisiblejintintID=NULL;
279 jstringgetClipboardContentsID=NULL;
280 voidpasteClipboardIntoConsoleID=NULL;
281 voidcopyConsoleSelectionID=NULL;
282 voidemptyClipboardID=NULL;
283 voidsetClipboardContentsjstringjava_lang_StringID=NULL;
284 voidcopyFigureToClipBoardjintintID=NULL;
285 jintgetScreenResolutionID=NULL;
286 jdoublegetScreenWidthID=NULL;
287 jdoublegetScreenHeightID=NULL;
288 jintgetScreenDepthID=NULL;
289 jbooleanprintFigurejintintjbooleanbooleanjbooleanbooleanID=NULL;
290 jbooleanprintFilejstringjava_lang_StringID=NULL;
291 jbooleanprintStringjstringjava_lang_Stringjstringjava_lang_StringID=NULL;
292 jbooleanpageSetupID=NULL;
293 voidrequestFocusjstringjava_lang_StringID=NULL;
294 voidraiseWindowjintintID=NULL;
295 voiduseCanvasForDisplayjbooleanbooleanID=NULL;
296 jbooleanuseCanvasForDisplayID=NULL;
297 voidscilabAboutBoxID=NULL;
298 voidsetUiTableColnamesjintintjstringjava_lang_StringID=NULL;
299 voidsetUiTableRownamesjintintjstringjava_lang_StringID=NULL;
300 voidsetUiTableDatajintintjstringjava_lang_StringID=NULL;
301 voidsetUiTreeDatajintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
302
303
304 }
305
306 CallScilabBridge::CallScilabBridge(JavaVM * jvm_, jobject JObj) {
307         jvm=jvm_;
308
309         JNIEnv * curEnv = getCurrentEnv();
310
311 jclass localClass = curEnv->GetObjectClass(JObj);
312         this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
313         curEnv->DeleteLocalRef(localClass);
314
315         if (this->instanceClass == NULL) {
316 throw GiwsException::JniObjectCreationException(curEnv, this->className());
317         }
318
319         this->instance = curEnv->NewGlobalRef(JObj) ;
320         if(this->instance == NULL){
321 throw GiwsException::JniObjectCreationException(curEnv, this->className());
322         }
323         /* Methods ID set to NULL */
324         jintnewWindowID=NULL;
325 jintnewMenuBarID=NULL;
326 jintnewMenuID=NULL;
327 jintnewPushButtonID=NULL;
328 jintnewPushButtonjstringjava_lang_StringID=NULL;
329 jintnewEditBoxID=NULL;
330 jintnewLabelID=NULL;
331 jintnewCheckBoxID=NULL;
332 jintnewRadioButtonID=NULL;
333 jintnewSliderID=NULL;
334 jintnewPopupMenuID=NULL;
335 jintnewListBoxID=NULL;
336 jintnewFrameID=NULL;
337 jintnewUiTableID=NULL;
338 jintnewUiDisplayTreeID=NULL;
339 jstringnewContextMenujobjectArray_java_lang_Stringjava_lang_StringID=NULL;
340 jintnewContextMenuID=NULL;
341 voiddestroyWidgetjintintID=NULL;
342 voiddestroyFramejintintID=NULL;
343 jintnewWindowjintintID=NULL;
344 voidsetFigureAsParentjintintjintintID=NULL;
345 voidsetMenuAsParentjintintjintintID=NULL;
346 voidsetRootAsParentjintintID=NULL;
347 voidsetParentjintintjintintID=NULL;
348 voidsetPushButtonParentjintintjintintID=NULL;
349 voidremovePushButtonFromParentjintintjintintID=NULL;
350 voidsetEditBoxParentjintintjintintID=NULL;
351 voidremoveEditBoxFromParentjintintjintintID=NULL;
352 voidsetLabelParentjintintjintintID=NULL;
353 voidremoveLabelFromParentjintintjintintID=NULL;
354 voidsetCheckBoxParentjintintjintintID=NULL;
355 voidremoveCheckBoxFromParentjintintjintintID=NULL;
356 voidsetRadioButtonParentjintintjintintID=NULL;
357 voidremoveRadioButtonFromParentjintintjintintID=NULL;
358 voidsetUiTableParentjintintjintintID=NULL;
359 voidremoveUiTableFromParentjintintjintintID=NULL;
360 voidsetUiDisplayTreeParentjintintjintintID=NULL;
361 voidremoveUiDisplayTreeFromParentjintintjintintID=NULL;
362 voidsetSliderParentjintintjintintID=NULL;
363 voidremoveSliderFromParentjintintjintintID=NULL;
364 voidsetPopupMenuParentjintintjintintID=NULL;
365 voidremovePopupMenuFromParentjintintjintintID=NULL;
366 voidsetListBoxParentjintintjintintID=NULL;
367 voidremoveListBoxFromParentjintintjintintID=NULL;
368 voidsetFrameParentjintintjintintID=NULL;
369 voidremoveFrameFromParentjintintjintintID=NULL;
370 voidsetWidgetTextjintintjstringjava_lang_StringID=NULL;
371 jstringgetWidgetTextjintintID=NULL;
372 voidsetFrameTextjintintjstringjava_lang_StringID=NULL;
373 jstringgetFrameTextjintintID=NULL;
374 voidsetWidgetBackgroundColorjintintjintintjintintjintintID=NULL;
375 jintArray_getWidgetBackgroundColorjintintID=NULL;
376 voidsetWidgetForegroundColorjintintjintintjintintjintintID=NULL;
377 jintArray_getWidgetForegroundColorjintintID=NULL;
378 voidsetFrameBackgroundColorjintintjintintjintintjintintID=NULL;
379 jintArray_getFrameBackgroundColorjintintID=NULL;
380 voidsetFrameForegroundColorjintintjintintjintintjintintID=NULL;
381 jintArray_getFrameForegroundColorjintintID=NULL;
382 voidsetWidgetFontNamejintintjstringjava_lang_StringID=NULL;
383 jstringgetWidgetFontNamejintintID=NULL;
384 voidsetWidgetFontWeightjintintjstringjava_lang_StringID=NULL;
385 voidsetWidgetFontSizejintintjintintID=NULL;
386 jintgetWidgetFontSizejintintID=NULL;
387 voidsetWidgetFontAnglejintintjstringjava_lang_StringID=NULL;
388 voidsetFrameFontNamejintintjstringjava_lang_StringID=NULL;
389 jstringgetFrameFontNamejintintID=NULL;
390 voidsetFrameFontWeightjintintjstringjava_lang_StringID=NULL;
391 voidsetFrameFontSizejintintjintintID=NULL;
392 jintgetFrameFontSizejintintID=NULL;
393 voidsetFrameFontAnglejintintjstringjava_lang_StringID=NULL;
394 voidsetWidgetPositionjintintjintintjintintjintintjintintID=NULL;
395 jintArray_getWidgetPositionjintintID=NULL;
396 voidsetFramePositionjintintjintintjintintjintintjintintID=NULL;
397 jintArray_getFramePositionjintintID=NULL;
398 voidsetWidgetCallbackjintintjstringjava_lang_StringjintintID=NULL;
399 voidsetFrameCallbackjintintjstringjava_lang_StringjintintID=NULL;
400 voidsetWidgetHorizontalAlignmentjintintjstringjava_lang_StringID=NULL;
401 voidsetWidgetVerticalAlignmentjintintjstringjava_lang_StringID=NULL;
402 voidsetSliderMinorTickSpacingjintintjintintID=NULL;
403 voidsetSliderMajorTickSpacingjintintjintintID=NULL;
404 voidsetListBoxSelectedIndicesjintintjintArray_intintID=NULL;
405 jintArray_getListBoxSelectedIndicesjintintID=NULL;
406 jintgetListBoxSelectionSizejintintID=NULL;
407 voidsetPopupMenuSelectedIndexjintintjintintID=NULL;
408 jintgetPopupMenuSelectedIndexjintintID=NULL;
409 voidsetSliderValuejintintjintintID=NULL;
410 jintgetSliderValuejintintID=NULL;
411 voidsetRadioButtonCheckedjintintjbooleanbooleanID=NULL;
412 jbooleanisRadioButtonCheckedjintintID=NULL;
413 voidsetCheckBoxCheckedjintintjbooleanbooleanID=NULL;
414 jbooleanisCheckBoxCheckedjintintID=NULL;
415 voidsetSliderMinValuejintintjintintID=NULL;
416 voidsetSliderMaxValuejintintjintintID=NULL;
417 voidsetSliderVerticaljintintID=NULL;
418 voidsetSliderHorizontaljintintID=NULL;
419 voidsetListBoxMultipleSelectionEnabledjintintjbooleanbooleanID=NULL;
420 jobjectArray_getListBoxAllItemsTextjintintID=NULL;
421 jintgetListBoxNumberOfItemsjintintID=NULL;
422 voidsetListBoxTextjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
423 voidsetListBoxListBoxTopjintintjintintID=NULL;
424 jintgetListBoxListBoxTopjintintID=NULL;
425 jobjectArray_getPopupMenuAllItemsTextjintintID=NULL;
426 jintgetPopupMenuNumberOfItemsjintintID=NULL;
427 voidsetPopupMenuTextjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
428 voidsetWidgetReliefjintintjstringjava_lang_StringID=NULL;
429 voidsetFrameReliefjintintjstringjava_lang_StringID=NULL;
430 voidsetMenuEnabledjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID=NULL;
431 voidsetSubMenuEnabledjstringjava_lang_Stringjstringjava_lang_StringjintintjbooleanbooleanID=NULL;
432 voidsetWidgetEnablejintintjbooleanbooleanID=NULL;
433 voidsetFrameEnablejintintjbooleanbooleanID=NULL;
434 jbooleanisWidgetEnablejintintID=NULL;
435 jbooleanisFrameEnablejintintID=NULL;
436 voidsetMenuCheckedjintintjbooleanbooleanID=NULL;
437 jbooleanisMenuCheckedjintintID=NULL;
438 voidremoveMenujstringjava_lang_Stringjstringjava_lang_StringID=NULL;
439 jstringdisplayAndWaitContextMenujstringjava_lang_StringID=NULL;
440 jintnewMessageBoxID=NULL;
441 voidsetMessageBoxTitlejintintjstringjava_lang_StringID=NULL;
442 voidsetMessageBoxMessagejintintjstringjava_lang_StringID=NULL;
443 voidsetMessageBoxMessagejintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
444 voidmessageBoxDisplayAndWaitjintintID=NULL;
445 jintgetMessageBoxSelectedButtonjintintID=NULL;
446 voidsetMessageBoxDefaultSelectedButtonsjintintjintArray_intintID=NULL;
447 jintArray_getMessageBoxUserSelectedButtonsjintintID=NULL;
448 voidsetMessageBoxButtonsLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
449 voidsetMessageBoxInitialValuejintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
450 jobjectArray_getMessageBoxValuejintintID=NULL;
451 jintgetMessageBoxValueSizejintintID=NULL;
452 voidsetMessageBoxListBoxItemsjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
453 jintgetMessageBoxSelectedItemjintintID=NULL;
454 voidsetMessageBoxLineLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
455 voidsetMessageBoxColumnLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
456 voidsetMessageBoxDefaultInputjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
457 voidsetMessageBoxModaljintintjbooleanbooleanID=NULL;
458 voidsetMessageBoxIconjintintjstringjava_lang_StringID=NULL;
459 jbooleanisToolbarVisiblejstringjava_lang_StringID=NULL;
460 voidsetToolbarVisiblejstringjava_lang_StringjbooleanbooleanID=NULL;
461 voidsetEventHandlerjintintjstringjava_lang_StringID=NULL;
462 voidsetEventHandlerEnabledjintintjbooleanbooleanID=NULL;
463 jintnewWaitBarID=NULL;
464 voidsetWaitBarMessagejintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
465 voidsetWaitBarValuejintintjintintID=NULL;
466 voiddestroyWaitBarjintintID=NULL;
467 voidsetWaitBarIndeterminateModejintintjbooleanbooleanID=NULL;
468 voidlaunchHelpBrowserjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_StringID=NULL;
469 voidsearchKeywordjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID=NULL;
470 jintnewExportFileChooserjintintID=NULL;
471 jintnewFontChooserID=NULL;
472 voidfontChooserDisplayAndWaitjintintID=NULL;
473 voidsetFontChooserFontNamejintintjstringjava_lang_StringID=NULL;
474 voidsetFontChooserFontSizejintintjintintID=NULL;
475 voidsetFontChooserBoldjintintjbooleanbooleanID=NULL;
476 voidsetFontChooserItalicjintintjbooleanbooleanID=NULL;
477 jstringgetFontChooserFontNamejintintID=NULL;
478 jintgetFontChooserFontSizejintintID=NULL;
479 jbooleangetFontChooserBoldjintintID=NULL;
480 jbooleangetFontChooserItalicjintintID=NULL;
481 jintnewColorChooserID=NULL;
482 voidcolorChooserDisplayAndWaitjintintID=NULL;
483 voidsetColorChooserDefaultColorjintintjintArray_intintID=NULL;
484 jintArray_getColorChooserSelectedColorjintintID=NULL;
485 voidsetColorChooserTitlejintintjstringjava_lang_StringID=NULL;
486 voidsetWidgetVisiblejintintjbooleanbooleanID=NULL;
487 voidsetFrameVisiblejintintjbooleanbooleanID=NULL;
488 jbooleanisWidgetVisiblejintintID=NULL;
489 jbooleanisFrameVisiblejintintID=NULL;
490 jstringgetClipboardContentsID=NULL;
491 voidpasteClipboardIntoConsoleID=NULL;
492 voidcopyConsoleSelectionID=NULL;
493 voidemptyClipboardID=NULL;
494 voidsetClipboardContentsjstringjava_lang_StringID=NULL;
495 voidcopyFigureToClipBoardjintintID=NULL;
496 jintgetScreenResolutionID=NULL;
497 jdoublegetScreenWidthID=NULL;
498 jdoublegetScreenHeightID=NULL;
499 jintgetScreenDepthID=NULL;
500 jbooleanprintFigurejintintjbooleanbooleanjbooleanbooleanID=NULL;
501 jbooleanprintFilejstringjava_lang_StringID=NULL;
502 jbooleanprintStringjstringjava_lang_Stringjstringjava_lang_StringID=NULL;
503 jbooleanpageSetupID=NULL;
504 voidrequestFocusjstringjava_lang_StringID=NULL;
505 voidraiseWindowjintintID=NULL;
506 voiduseCanvasForDisplayjbooleanbooleanID=NULL;
507 jbooleanuseCanvasForDisplayID=NULL;
508 voidscilabAboutBoxID=NULL;
509 voidsetUiTableColnamesjintintjstringjava_lang_StringID=NULL;
510 voidsetUiTableRownamesjintintjstringjava_lang_StringID=NULL;
511 voidsetUiTableDatajintintjstringjava_lang_StringID=NULL;
512 voidsetUiTreeDatajintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
513
514
515 }
516
517 // Generic methods
518
519 void CallScilabBridge::synchronize() {
520 if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
521 throw GiwsException::JniMonitorException(getCurrentEnv(), "CallScilabBridge");
522 }
523 }
524
525 void CallScilabBridge::endSynchronize() {
526 if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
527 throw GiwsException::JniMonitorException(getCurrentEnv(), "CallScilabBridge");
528 }
529 }
530 // Method(s)
531
532 int CallScilabBridge::newWindow (JavaVM * jvm_){
533
534 JNIEnv * curEnv = NULL;
535 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
536 jclass cls = curEnv->FindClass( className().c_str() );
537
538 jmethodID jintnewWindowID = curEnv->GetStaticMethodID(cls, "newWindow", "()I" ) ;
539 if (jintnewWindowID == NULL) {
540 throw GiwsException::JniMethodNotFoundException(curEnv, "newWindow");
541 }
542
543                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewWindowID ));
544                         curEnv->DeleteLocalRef(cls);
545 if (curEnv->ExceptionCheck()) {
546 throw GiwsException::JniCallMethodException(curEnv);
547 }
548 return res;
549
550 }
551
552 int CallScilabBridge::newMenuBar (JavaVM * jvm_){
553
554 JNIEnv * curEnv = NULL;
555 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
556 jclass cls = curEnv->FindClass( className().c_str() );
557
558 jmethodID jintnewMenuBarID = curEnv->GetStaticMethodID(cls, "newMenuBar", "()I" ) ;
559 if (jintnewMenuBarID == NULL) {
560 throw GiwsException::JniMethodNotFoundException(curEnv, "newMenuBar");
561 }
562
563                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewMenuBarID ));
564                         curEnv->DeleteLocalRef(cls);
565 if (curEnv->ExceptionCheck()) {
566 throw GiwsException::JniCallMethodException(curEnv);
567 }
568 return res;
569
570 }
571
572 int CallScilabBridge::newMenu (JavaVM * jvm_){
573
574 JNIEnv * curEnv = NULL;
575 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
576 jclass cls = curEnv->FindClass( className().c_str() );
577
578 jmethodID jintnewMenuID = curEnv->GetStaticMethodID(cls, "newMenu", "()I" ) ;
579 if (jintnewMenuID == NULL) {
580 throw GiwsException::JniMethodNotFoundException(curEnv, "newMenu");
581 }
582
583                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewMenuID ));
584                         curEnv->DeleteLocalRef(cls);
585 if (curEnv->ExceptionCheck()) {
586 throw GiwsException::JniCallMethodException(curEnv);
587 }
588 return res;
589
590 }
591
592 int CallScilabBridge::newPushButton (JavaVM * jvm_){
593
594 JNIEnv * curEnv = NULL;
595 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
596 jclass cls = curEnv->FindClass( className().c_str() );
597
598 jmethodID jintnewPushButtonID = curEnv->GetStaticMethodID(cls, "newPushButton", "()I" ) ;
599 if (jintnewPushButtonID == NULL) {
600 throw GiwsException::JniMethodNotFoundException(curEnv, "newPushButton");
601 }
602
603                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewPushButtonID ));
604                         curEnv->DeleteLocalRef(cls);
605 if (curEnv->ExceptionCheck()) {
606 throw GiwsException::JniCallMethodException(curEnv);
607 }
608 return res;
609
610 }
611
612 int CallScilabBridge::newPushButton (JavaVM * jvm_, char const* UID){
613
614 JNIEnv * curEnv = NULL;
615 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
616 jclass cls = curEnv->FindClass( className().c_str() );
617
618 jmethodID jintnewPushButtonjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "newPushButton", "(Ljava/lang/String;)I" ) ;
619 if (jintnewPushButtonjstringjava_lang_StringID == NULL) {
620 throw GiwsException::JniMethodNotFoundException(curEnv, "newPushButton");
621 }
622
623 jstring UID_ = curEnv->NewStringUTF( UID );
624 if (UID != NULL && UID_ == NULL)
625 {
626 throw GiwsException::JniBadAllocException(curEnv);
627 }
628
629
630                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewPushButtonjstringjava_lang_StringID ,UID_));
631                         curEnv->DeleteLocalRef(UID_);
632 curEnv->DeleteLocalRef(cls);
633 if (curEnv->ExceptionCheck()) {
634 throw GiwsException::JniCallMethodException(curEnv);
635 }
636 return res;
637
638 }
639
640 int CallScilabBridge::newEditBox (JavaVM * jvm_){
641
642 JNIEnv * curEnv = NULL;
643 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
644 jclass cls = curEnv->FindClass( className().c_str() );
645
646 jmethodID jintnewEditBoxID = curEnv->GetStaticMethodID(cls, "newEditBox", "()I" ) ;
647 if (jintnewEditBoxID == NULL) {
648 throw GiwsException::JniMethodNotFoundException(curEnv, "newEditBox");
649 }
650
651                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewEditBoxID ));
652                         curEnv->DeleteLocalRef(cls);
653 if (curEnv->ExceptionCheck()) {
654 throw GiwsException::JniCallMethodException(curEnv);
655 }
656 return res;
657
658 }
659
660 int CallScilabBridge::newLabel (JavaVM * jvm_){
661
662 JNIEnv * curEnv = NULL;
663 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
664 jclass cls = curEnv->FindClass( className().c_str() );
665
666 jmethodID jintnewLabelID = curEnv->GetStaticMethodID(cls, "newLabel", "()I" ) ;
667 if (jintnewLabelID == NULL) {
668 throw GiwsException::JniMethodNotFoundException(curEnv, "newLabel");
669 }
670
671                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewLabelID ));
672                         curEnv->DeleteLocalRef(cls);
673 if (curEnv->ExceptionCheck()) {
674 throw GiwsException::JniCallMethodException(curEnv);
675 }
676 return res;
677
678 }
679
680 int CallScilabBridge::newCheckBox (JavaVM * jvm_){
681
682 JNIEnv * curEnv = NULL;
683 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
684 jclass cls = curEnv->FindClass( className().c_str() );
685
686 jmethodID jintnewCheckBoxID = curEnv->GetStaticMethodID(cls, "newCheckBox", "()I" ) ;
687 if (jintnewCheckBoxID == NULL) {
688 throw GiwsException::JniMethodNotFoundException(curEnv, "newCheckBox");
689 }
690
691                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewCheckBoxID ));
692                         curEnv->DeleteLocalRef(cls);
693 if (curEnv->ExceptionCheck()) {
694 throw GiwsException::JniCallMethodException(curEnv);
695 }
696 return res;
697
698 }
699
700 int CallScilabBridge::newRadioButton (JavaVM * jvm_){
701
702 JNIEnv * curEnv = NULL;
703 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
704 jclass cls = curEnv->FindClass( className().c_str() );
705
706 jmethodID jintnewRadioButtonID = curEnv->GetStaticMethodID(cls, "newRadioButton", "()I" ) ;
707 if (jintnewRadioButtonID == NULL) {
708 throw GiwsException::JniMethodNotFoundException(curEnv, "newRadioButton");
709 }
710
711                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewRadioButtonID ));
712                         curEnv->DeleteLocalRef(cls);
713 if (curEnv->ExceptionCheck()) {
714 throw GiwsException::JniCallMethodException(curEnv);
715 }
716 return res;
717
718 }
719
720 int CallScilabBridge::newSlider (JavaVM * jvm_){
721
722 JNIEnv * curEnv = NULL;
723 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
724 jclass cls = curEnv->FindClass( className().c_str() );
725
726 jmethodID jintnewSliderID = curEnv->GetStaticMethodID(cls, "newSlider", "()I" ) ;
727 if (jintnewSliderID == NULL) {
728 throw GiwsException::JniMethodNotFoundException(curEnv, "newSlider");
729 }
730
731                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewSliderID ));
732                         curEnv->DeleteLocalRef(cls);
733 if (curEnv->ExceptionCheck()) {
734 throw GiwsException::JniCallMethodException(curEnv);
735 }
736 return res;
737
738 }
739
740 int CallScilabBridge::newPopupMenu (JavaVM * jvm_){
741
742 JNIEnv * curEnv = NULL;
743 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
744 jclass cls = curEnv->FindClass( className().c_str() );
745
746 jmethodID jintnewPopupMenuID = curEnv->GetStaticMethodID(cls, "newPopupMenu", "()I" ) ;
747 if (jintnewPopupMenuID == NULL) {
748 throw GiwsException::JniMethodNotFoundException(curEnv, "newPopupMenu");
749 }
750
751                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewPopupMenuID ));
752                         curEnv->DeleteLocalRef(cls);
753 if (curEnv->ExceptionCheck()) {
754 throw GiwsException::JniCallMethodException(curEnv);
755 }
756 return res;
757
758 }
759
760 int CallScilabBridge::newListBox (JavaVM * jvm_){
761
762 JNIEnv * curEnv = NULL;
763 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
764 jclass cls = curEnv->FindClass( className().c_str() );
765
766 jmethodID jintnewListBoxID = curEnv->GetStaticMethodID(cls, "newListBox", "()I" ) ;
767 if (jintnewListBoxID == NULL) {
768 throw GiwsException::JniMethodNotFoundException(curEnv, "newListBox");
769 }
770
771                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewListBoxID ));
772                         curEnv->DeleteLocalRef(cls);
773 if (curEnv->ExceptionCheck()) {
774 throw GiwsException::JniCallMethodException(curEnv);
775 }
776 return res;
777
778 }
779
780 int CallScilabBridge::newFrame (JavaVM * jvm_){
781
782 JNIEnv * curEnv = NULL;
783 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
784 jclass cls = curEnv->FindClass( className().c_str() );
785
786 jmethodID jintnewFrameID = curEnv->GetStaticMethodID(cls, "newFrame", "()I" ) ;
787 if (jintnewFrameID == NULL) {
788 throw GiwsException::JniMethodNotFoundException(curEnv, "newFrame");
789 }
790
791                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewFrameID ));
792                         curEnv->DeleteLocalRef(cls);
793 if (curEnv->ExceptionCheck()) {
794 throw GiwsException::JniCallMethodException(curEnv);
795 }
796 return res;
797
798 }
799
800 int CallScilabBridge::newUiTable (JavaVM * jvm_){
801
802 JNIEnv * curEnv = NULL;
803 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
804 jclass cls = curEnv->FindClass( className().c_str() );
805
806 jmethodID jintnewUiTableID = curEnv->GetStaticMethodID(cls, "newUiTable", "()I" ) ;
807 if (jintnewUiTableID == NULL) {
808 throw GiwsException::JniMethodNotFoundException(curEnv, "newUiTable");
809 }
810
811                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewUiTableID ));
812                         curEnv->DeleteLocalRef(cls);
813 if (curEnv->ExceptionCheck()) {
814 throw GiwsException::JniCallMethodException(curEnv);
815 }
816 return res;
817
818 }
819
820 int CallScilabBridge::newUiDisplayTree (JavaVM * jvm_){
821
822 JNIEnv * curEnv = NULL;
823 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
824 jclass cls = curEnv->FindClass( className().c_str() );
825
826 jmethodID jintnewUiDisplayTreeID = curEnv->GetStaticMethodID(cls, "newUiDisplayTree", "()I" ) ;
827 if (jintnewUiDisplayTreeID == NULL) {
828 throw GiwsException::JniMethodNotFoundException(curEnv, "newUiDisplayTree");
829 }
830
831                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewUiDisplayTreeID ));
832                         curEnv->DeleteLocalRef(cls);
833 if (curEnv->ExceptionCheck()) {
834 throw GiwsException::JniCallMethodException(curEnv);
835 }
836 return res;
837
838 }
839
840 char* CallScilabBridge::newContextMenu (JavaVM * jvm_, char const* const* menuLabels, int menuLabelsSize){
841
842 JNIEnv * curEnv = NULL;
843 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
844 jclass cls = curEnv->FindClass( className().c_str() );
845
846 jmethodID jstringnewContextMenujobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "newContextMenu", "([Ljava/lang/String;)Ljava/lang/String;" ) ;
847 if (jstringnewContextMenujobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
848 throw GiwsException::JniMethodNotFoundException(curEnv, "newContextMenu");
849 }
850 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
851
852 // create java array of strings.
853 jobjectArray menuLabels_ = curEnv->NewObjectArray( menuLabelsSize, stringArrayClass, NULL);
854 if (menuLabels_ == NULL)
855 {
856 throw GiwsException::JniBadAllocException(curEnv);
857 }
858
859 // convert each char * to java strings and fill the java array.
860 for ( int i = 0; i < menuLabelsSize; i++)
861 {
862 jstring TempString = curEnv->NewStringUTF( menuLabels[i] );
863 if (TempString == NULL)
864 {
865 throw GiwsException::JniBadAllocException(curEnv);
866 }
867
868 curEnv->SetObjectArrayElement( menuLabels_, i, TempString);
869
870 // avoid keeping reference on to many strings
871 curEnv->DeleteLocalRef(TempString);
872 }
873                         jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringnewContextMenujobjectArray_java_lang_Stringjava_lang_StringID ,menuLabels_));
874                         if (curEnv->ExceptionCheck()) {
875 throw GiwsException::JniCallMethodException(curEnv);
876 }
877
878 const char *tempString = curEnv->GetStringUTFChars(res, 0);
879 char * myStringBuffer = new char[strlen(tempString) + 1];
880 strcpy(myStringBuffer, tempString);
881 curEnv->ReleaseStringUTFChars(res, tempString);
882 curEnv->DeleteLocalRef(res);
883 curEnv->DeleteLocalRef(stringArrayClass);
884 curEnv->DeleteLocalRef(menuLabels_);
885 curEnv->DeleteLocalRef(cls);
886 if (curEnv->ExceptionCheck()) {
887 delete[] myStringBuffer;
888                                 throw GiwsException::JniCallMethodException(curEnv);
889 }
890 return myStringBuffer;
891
892 }
893
894 int CallScilabBridge::newContextMenu (JavaVM * jvm_){
895
896 JNIEnv * curEnv = NULL;
897 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
898 jclass cls = curEnv->FindClass( className().c_str() );
899
900 jmethodID jintnewContextMenuID = curEnv->GetStaticMethodID(cls, "newContextMenu", "()I" ) ;
901 if (jintnewContextMenuID == NULL) {
902 throw GiwsException::JniMethodNotFoundException(curEnv, "newContextMenu");
903 }
904
905                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewContextMenuID ));
906                         curEnv->DeleteLocalRef(cls);
907 if (curEnv->ExceptionCheck()) {
908 throw GiwsException::JniCallMethodException(curEnv);
909 }
910 return res;
911
912 }
913
914 void CallScilabBridge::destroyWidget (JavaVM * jvm_, int objID){
915
916 JNIEnv * curEnv = NULL;
917 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
918 jclass cls = curEnv->FindClass( className().c_str() );
919
920 jmethodID voiddestroyWidgetjintintID = curEnv->GetStaticMethodID(cls, "destroyWidget", "(I)V" ) ;
921 if (voiddestroyWidgetjintintID == NULL) {
922 throw GiwsException::JniMethodNotFoundException(curEnv, "destroyWidget");
923 }
924
925                          curEnv->CallStaticVoidMethod(cls, voiddestroyWidgetjintintID ,objID);
926                         curEnv->DeleteLocalRef(cls);
927 if (curEnv->ExceptionCheck()) {
928 throw GiwsException::JniCallMethodException(curEnv);
929 }
930 }
931
932 void CallScilabBridge::destroyFrame (JavaVM * jvm_, int objID){
933
934 JNIEnv * curEnv = NULL;
935 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
936 jclass cls = curEnv->FindClass( className().c_str() );
937
938 jmethodID voiddestroyFramejintintID = curEnv->GetStaticMethodID(cls, "destroyFrame", "(I)V" ) ;
939 if (voiddestroyFramejintintID == NULL) {
940 throw GiwsException::JniMethodNotFoundException(curEnv, "destroyFrame");
941 }
942
943                          curEnv->CallStaticVoidMethod(cls, voiddestroyFramejintintID ,objID);
944                         curEnv->DeleteLocalRef(cls);
945 if (curEnv->ExceptionCheck()) {
946 throw GiwsException::JniCallMethodException(curEnv);
947 }
948 }
949
950 int CallScilabBridge::newWindow (JavaVM * jvm_, int figureIndex){
951
952 JNIEnv * curEnv = NULL;
953 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
954 jclass cls = curEnv->FindClass( className().c_str() );
955
956 jmethodID jintnewWindowjintintID = curEnv->GetStaticMethodID(cls, "newWindow", "(I)I" ) ;
957 if (jintnewWindowjintintID == NULL) {
958 throw GiwsException::JniMethodNotFoundException(curEnv, "newWindow");
959 }
960
961                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewWindowjintintID ,figureIndex));
962                         curEnv->DeleteLocalRef(cls);
963 if (curEnv->ExceptionCheck()) {
964 throw GiwsException::JniCallMethodException(curEnv);
965 }
966 return res;
967
968 }
969
970 void CallScilabBridge::setFigureAsParent (JavaVM * jvm_, int figureID, int objID){
971
972 JNIEnv * curEnv = NULL;
973 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
974 jclass cls = curEnv->FindClass( className().c_str() );
975
976 jmethodID voidsetFigureAsParentjintintjintintID = curEnv->GetStaticMethodID(cls, "setFigureAsParent", "(II)V" ) ;
977 if (voidsetFigureAsParentjintintjintintID == NULL) {
978 throw GiwsException::JniMethodNotFoundException(curEnv, "setFigureAsParent");
979 }
980
981                          curEnv->CallStaticVoidMethod(cls, voidsetFigureAsParentjintintjintintID ,figureID, objID);
982                         curEnv->DeleteLocalRef(cls);
983 if (curEnv->ExceptionCheck()) {
984 throw GiwsException::JniCallMethodException(curEnv);
985 }
986 }
987
988 void CallScilabBridge::setMenuAsParent (JavaVM * jvm_, int menuID, int objID){
989
990 JNIEnv * curEnv = NULL;
991 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
992 jclass cls = curEnv->FindClass( className().c_str() );
993
994 jmethodID voidsetMenuAsParentjintintjintintID = curEnv->GetStaticMethodID(cls, "setMenuAsParent", "(II)V" ) ;
995 if (voidsetMenuAsParentjintintjintintID == NULL) {
996 throw GiwsException::JniMethodNotFoundException(curEnv, "setMenuAsParent");
997 }
998
999                          curEnv->CallStaticVoidMethod(cls, voidsetMenuAsParentjintintjintintID ,menuID, objID);
1000                         curEnv->DeleteLocalRef(cls);
1001 if (curEnv->ExceptionCheck()) {
1002 throw GiwsException::JniCallMethodException(curEnv);
1003 }
1004 }
1005
1006 void CallScilabBridge::setRootAsParent (JavaVM * jvm_, int objID){
1007
1008 JNIEnv * curEnv = NULL;
1009 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1010 jclass cls = curEnv->FindClass( className().c_str() );
1011
1012 jmethodID voidsetRootAsParentjintintID = curEnv->GetStaticMethodID(cls, "setRootAsParent", "(I)V" ) ;
1013 if (voidsetRootAsParentjintintID == NULL) {
1014 throw GiwsException::JniMethodNotFoundException(curEnv, "setRootAsParent");
1015 }
1016
1017                          curEnv->CallStaticVoidMethod(cls, voidsetRootAsParentjintintID ,objID);
1018                         curEnv->DeleteLocalRef(cls);
1019 if (curEnv->ExceptionCheck()) {
1020 throw GiwsException::JniCallMethodException(curEnv);
1021 }
1022 }
1023
1024 void CallScilabBridge::setParent (JavaVM * jvm_, int parentID, int objID){
1025
1026 JNIEnv * curEnv = NULL;
1027 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1028 jclass cls = curEnv->FindClass( className().c_str() );
1029
1030 jmethodID voidsetParentjintintjintintID = curEnv->GetStaticMethodID(cls, "setParent", "(II)V" ) ;
1031 if (voidsetParentjintintjintintID == NULL) {
1032 throw GiwsException::JniMethodNotFoundException(curEnv, "setParent");
1033 }
1034
1035                          curEnv->CallStaticVoidMethod(cls, voidsetParentjintintjintintID ,parentID, objID);
1036                         curEnv->DeleteLocalRef(cls);
1037 if (curEnv->ExceptionCheck()) {
1038 throw GiwsException::JniCallMethodException(curEnv);
1039 }
1040 }
1041
1042 void CallScilabBridge::setPushButtonParent (JavaVM * jvm_, int parentID, int objID){
1043
1044 JNIEnv * curEnv = NULL;
1045 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1046 jclass cls = curEnv->FindClass( className().c_str() );
1047
1048 jmethodID voidsetPushButtonParentjintintjintintID = curEnv->GetStaticMethodID(cls, "setPushButtonParent", "(II)V" ) ;
1049 if (voidsetPushButtonParentjintintjintintID == NULL) {
1050 throw GiwsException::JniMethodNotFoundException(curEnv, "setPushButtonParent");
1051 }
1052
1053                          curEnv->CallStaticVoidMethod(cls, voidsetPushButtonParentjintintjintintID ,parentID, objID);
1054                         curEnv->DeleteLocalRef(cls);
1055 if (curEnv->ExceptionCheck()) {
1056 throw GiwsException::JniCallMethodException(curEnv);
1057 }
1058 }
1059
1060 void CallScilabBridge::removePushButtonFromParent (JavaVM * jvm_, int parentID, int objID){
1061
1062 JNIEnv * curEnv = NULL;
1063 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1064 jclass cls = curEnv->FindClass( className().c_str() );
1065
1066 jmethodID voidremovePushButtonFromParentjintintjintintID = curEnv->GetStaticMethodID(cls, "removePushButtonFromParent", "(II)V" ) ;
1067 if (voidremovePushButtonFromParentjintintjintintID == NULL) {
1068 throw GiwsException::JniMethodNotFoundException(curEnv, "removePushButtonFromParent");
1069 }
1070
1071                          curEnv->CallStaticVoidMethod(cls, voidremovePushButtonFromParentjintintjintintID ,parentID, objID);
1072                         curEnv->DeleteLocalRef(cls);
1073 if (curEnv->ExceptionCheck()) {
1074 throw GiwsException::JniCallMethodException(curEnv);
1075 }
1076 }
1077
1078 void CallScilabBridge::setEditBoxParent (JavaVM * jvm_, int parentID, int objID){
1079
1080 JNIEnv * curEnv = NULL;
1081 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1082 jclass cls = curEnv->FindClass( className().c_str() );
1083
1084 jmethodID voidsetEditBoxParentjintintjintintID = curEnv->GetStaticMethodID(cls, "setEditBoxParent", "(II)V" ) ;
1085 if (voidsetEditBoxParentjintintjintintID == NULL) {
1086 throw GiwsException::JniMethodNotFoundException(curEnv, "setEditBoxParent");
1087 }
1088
1089                          curEnv->CallStaticVoidMethod(cls, voidsetEditBoxParentjintintjintintID ,parentID, objID);
1090                         curEnv->DeleteLocalRef(cls);
1091 if (curEnv->ExceptionCheck()) {
1092 throw GiwsException::JniCallMethodException(curEnv);
1093 }
1094 }
1095
1096 void CallScilabBridge::removeEditBoxFromParent (JavaVM * jvm_, int parentID, int objID){
1097
1098 JNIEnv * curEnv = NULL;
1099 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1100 jclass cls = curEnv->FindClass( className().c_str() );
1101
1102 jmethodID voidremoveEditBoxFromParentjintintjintintID = curEnv->GetStaticMethodID(cls, "removeEditBoxFromParent", "(II)V" ) ;
1103 if (voidremoveEditBoxFromParentjintintjintintID == NULL) {
1104 throw GiwsException::JniMethodNotFoundException(curEnv, "removeEditBoxFromParent");
1105 }
1106
1107                          curEnv->CallStaticVoidMethod(cls, voidremoveEditBoxFromParentjintintjintintID ,parentID, objID);
1108                         curEnv->DeleteLocalRef(cls);
1109 if (curEnv->ExceptionCheck()) {
1110 throw GiwsException::JniCallMethodException(curEnv);
1111 }
1112 }
1113
1114 void CallScilabBridge::setLabelParent (JavaVM * jvm_, int parentID, int objID){
1115
1116 JNIEnv * curEnv = NULL;
1117 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1118 jclass cls = curEnv->FindClass( className().c_str() );
1119
1120 jmethodID voidsetLabelParentjintintjintintID = curEnv->GetStaticMethodID(cls, "setLabelParent", "(II)V" ) ;
1121 if (voidsetLabelParentjintintjintintID == NULL) {
1122 throw GiwsException::JniMethodNotFoundException(curEnv, "setLabelParent");
1123 }
1124
1125                          curEnv->CallStaticVoidMethod(cls, voidsetLabelParentjintintjintintID ,parentID, objID);
1126                         curEnv->DeleteLocalRef(cls);
1127 if (curEnv->ExceptionCheck()) {
1128 throw GiwsException::JniCallMethodException(curEnv);
1129 }
1130 }
1131
1132 void CallScilabBridge::removeLabelFromParent (JavaVM * jvm_, int parentID, int objID){
1133
1134 JNIEnv * curEnv = NULL;
1135 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1136 jclass cls = curEnv->FindClass( className().c_str() );
1137
1138 jmethodID voidremoveLabelFromParentjintintjintintID = curEnv->GetStaticMethodID(cls, "removeLabelFromParent", "(II)V" ) ;
1139 if (voidremoveLabelFromParentjintintjintintID == NULL) {
1140 throw GiwsException::JniMethodNotFoundException(curEnv, "removeLabelFromParent");
1141 }
1142
1143                          curEnv->CallStaticVoidMethod(cls, voidremoveLabelFromParentjintintjintintID ,parentID, objID);
1144                         curEnv->DeleteLocalRef(cls);
1145 if (curEnv->ExceptionCheck()) {
1146 throw GiwsException::JniCallMethodException(curEnv);
1147 }
1148 }
1149
1150 void CallScilabBridge::setCheckBoxParent (JavaVM * jvm_, int parentID, int objID){
1151
1152 JNIEnv * curEnv = NULL;
1153 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1154 jclass cls = curEnv->FindClass( className().c_str() );
1155
1156 jmethodID voidsetCheckBoxParentjintintjintintID = curEnv->GetStaticMethodID(cls, "setCheckBoxParent", "(II)V" ) ;
1157 if (voidsetCheckBoxParentjintintjintintID == NULL) {
1158 throw GiwsException::JniMethodNotFoundException(curEnv, "setCheckBoxParent");
1159 }
1160
1161                          curEnv->CallStaticVoidMethod(cls, voidsetCheckBoxParentjintintjintintID ,parentID, objID);
1162                         curEnv->DeleteLocalRef(cls);
1163 if (curEnv->ExceptionCheck()) {
1164 throw GiwsException::JniCallMethodException(curEnv);
1165 }
1166 }
1167
1168 void CallScilabBridge::removeCheckBoxFromParent (JavaVM * jvm_, int parentID, int objID){
1169
1170 JNIEnv * curEnv = NULL;
1171 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1172 jclass cls = curEnv->FindClass( className().c_str() );
1173
1174 jmethodID voidremoveCheckBoxFromParentjintintjintintID = curEnv->GetStaticMethodID(cls, "removeCheckBoxFromParent", "(II)V" ) ;
1175 if (voidremoveCheckBoxFromParentjintintjintintID == NULL) {
1176 throw GiwsException::JniMethodNotFoundException(curEnv, "removeCheckBoxFromParent");
1177 }
1178
1179                          curEnv->CallStaticVoidMethod(cls, voidremoveCheckBoxFromParentjintintjintintID ,parentID, objID);
1180                         curEnv->DeleteLocalRef(cls);
1181 if (curEnv->ExceptionCheck()) {
1182 throw GiwsException::JniCallMethodException(curEnv);
1183 }
1184 }
1185
1186 void CallScilabBridge::setRadioButtonParent (JavaVM * jvm_, int parentID, int objID){
1187
1188 JNIEnv * curEnv = NULL;
1189 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1190 jclass cls = curEnv->FindClass( className().c_str() );
1191
1192 jmethodID voidsetRadioButtonParentjintintjintintID = curEnv->GetStaticMethodID(cls, "setRadioButtonParent", "(II)V" ) ;
1193 if (voidsetRadioButtonParentjintintjintintID == NULL) {
1194 throw GiwsException::JniMethodNotFoundException(curEnv, "setRadioButtonParent");
1195 }
1196
1197                          curEnv->CallStaticVoidMethod(cls, voidsetRadioButtonParentjintintjintintID ,parentID, objID);
1198                         curEnv->DeleteLocalRef(cls);
1199 if (curEnv->ExceptionCheck()) {
1200 throw GiwsException::JniCallMethodException(curEnv);
1201 }
1202 }
1203
1204 void CallScilabBridge::removeRadioButtonFromParent (JavaVM * jvm_, int parentID, int objID){
1205
1206 JNIEnv * curEnv = NULL;
1207 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1208 jclass cls = curEnv->FindClass( className().c_str() );
1209
1210 jmethodID voidremoveRadioButtonFromParentjintintjintintID = curEnv->GetStaticMethodID(cls, "removeRadioButtonFromParent", "(II)V" ) ;
1211 if (voidremoveRadioButtonFromParentjintintjintintID == NULL) {
1212 throw GiwsException::JniMethodNotFoundException(curEnv, "removeRadioButtonFromParent");
1213 }
1214
1215                          curEnv->CallStaticVoidMethod(cls, voidremoveRadioButtonFromParentjintintjintintID ,parentID, objID);
1216                         curEnv->DeleteLocalRef(cls);
1217 if (curEnv->ExceptionCheck()) {
1218 throw GiwsException::JniCallMethodException(curEnv);
1219 }
1220 }
1221
1222 void CallScilabBridge::setUiTableParent (JavaVM * jvm_, int parentID, int objID){
1223
1224 JNIEnv * curEnv = NULL;
1225 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1226 jclass cls = curEnv->FindClass( className().c_str() );
1227
1228 jmethodID voidsetUiTableParentjintintjintintID = curEnv->GetStaticMethodID(cls, "setUiTableParent", "(II)V" ) ;
1229 if (voidsetUiTableParentjintintjintintID == NULL) {
1230 throw GiwsException::JniMethodNotFoundException(curEnv, "setUiTableParent");
1231 }
1232
1233                          curEnv->CallStaticVoidMethod(cls, voidsetUiTableParentjintintjintintID ,parentID, objID);
1234                         curEnv->DeleteLocalRef(cls);
1235 if (curEnv->ExceptionCheck()) {
1236 throw GiwsException::JniCallMethodException(curEnv);
1237 }
1238 }
1239
1240 void CallScilabBridge::removeUiTableFromParent (JavaVM * jvm_, int parentID, int objID){
1241
1242 JNIEnv * curEnv = NULL;
1243 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1244 jclass cls = curEnv->FindClass( className().c_str() );
1245
1246 jmethodID voidremoveUiTableFromParentjintintjintintID = curEnv->GetStaticMethodID(cls, "removeUiTableFromParent", "(II)V" ) ;
1247 if (voidremoveUiTableFromParentjintintjintintID == NULL) {
1248 throw GiwsException::JniMethodNotFoundException(curEnv, "removeUiTableFromParent");
1249 }
1250
1251                          curEnv->CallStaticVoidMethod(cls, voidremoveUiTableFromParentjintintjintintID ,parentID, objID);
1252                         curEnv->DeleteLocalRef(cls);
1253 if (curEnv->ExceptionCheck()) {
1254 throw GiwsException::JniCallMethodException(curEnv);
1255 }
1256 }
1257
1258 void CallScilabBridge::setUiDisplayTreeParent (JavaVM * jvm_, int parentID, int objID){
1259
1260 JNIEnv * curEnv = NULL;
1261 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1262 jclass cls = curEnv->FindClass( className().c_str() );
1263
1264 jmethodID voidsetUiDisplayTreeParentjintintjintintID = curEnv->GetStaticMethodID(cls, "setUiDisplayTreeParent", "(II)V" ) ;
1265 if (voidsetUiDisplayTreeParentjintintjintintID == NULL) {
1266 throw GiwsException::JniMethodNotFoundException(curEnv, "setUiDisplayTreeParent");
1267 }
1268
1269                          curEnv->CallStaticVoidMethod(cls, voidsetUiDisplayTreeParentjintintjintintID ,parentID, objID);
1270                         curEnv->DeleteLocalRef(cls);
1271 if (curEnv->ExceptionCheck()) {
1272 throw GiwsException::JniCallMethodException(curEnv);
1273 }
1274 }
1275
1276 void CallScilabBridge::removeUiDisplayTreeFromParent (JavaVM * jvm_, int parentID, int objID){
1277
1278 JNIEnv * curEnv = NULL;
1279 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1280 jclass cls = curEnv->FindClass( className().c_str() );
1281
1282 jmethodID voidremoveUiDisplayTreeFromParentjintintjintintID = curEnv->GetStaticMethodID(cls, "removeUiDisplayTreeFromParent", "(II)V" ) ;
1283 if (voidremoveUiDisplayTreeFromParentjintintjintintID == NULL) {
1284 throw GiwsException::JniMethodNotFoundException(curEnv, "removeUiDisplayTreeFromParent");
1285 }
1286
1287                          curEnv->CallStaticVoidMethod(cls, voidremoveUiDisplayTreeFromParentjintintjintintID ,parentID, objID);
1288                         curEnv->DeleteLocalRef(cls);
1289 if (curEnv->ExceptionCheck()) {
1290 throw GiwsException::JniCallMethodException(curEnv);
1291 }
1292 }
1293
1294 void CallScilabBridge::setSliderParent (JavaVM * jvm_, int parentID, int objID){
1295
1296 JNIEnv * curEnv = NULL;
1297 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1298 jclass cls = curEnv->FindClass( className().c_str() );
1299
1300 jmethodID voidsetSliderParentjintintjintintID = curEnv->GetStaticMethodID(cls, "setSliderParent", "(II)V" ) ;
1301 if (voidsetSliderParentjintintjintintID == NULL) {
1302 throw GiwsException::JniMethodNotFoundException(curEnv, "setSliderParent");
1303 }
1304
1305                          curEnv->CallStaticVoidMethod(cls, voidsetSliderParentjintintjintintID ,parentID, objID);
1306                         curEnv->DeleteLocalRef(cls);
1307 if (curEnv->ExceptionCheck()) {
1308 throw GiwsException::JniCallMethodException(curEnv);
1309 }
1310 }
1311
1312 void CallScilabBridge::removeSliderFromParent (JavaVM * jvm_, int parentID, int objID){
1313
1314 JNIEnv * curEnv = NULL;
1315 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1316 jclass cls = curEnv->FindClass( className().c_str() );
1317
1318 jmethodID voidremoveSliderFromParentjintintjintintID = curEnv->GetStaticMethodID(cls, "removeSliderFromParent", "(II)V" ) ;
1319 if (voidremoveSliderFromParentjintintjintintID == NULL) {
1320 throw GiwsException::JniMethodNotFoundException(curEnv, "removeSliderFromParent");
1321 }
1322
1323                          curEnv->CallStaticVoidMethod(cls, voidremoveSliderFromParentjintintjintintID ,parentID, objID);
1324                         curEnv->DeleteLocalRef(cls);
1325 if (curEnv->ExceptionCheck()) {
1326 throw GiwsException::JniCallMethodException(curEnv);
1327 }
1328 }
1329
1330 void CallScilabBridge::setPopupMenuParent (JavaVM * jvm_, int parentID, int objID){
1331
1332 JNIEnv * curEnv = NULL;
1333 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1334 jclass cls = curEnv->FindClass( className().c_str() );
1335
1336 jmethodID voidsetPopupMenuParentjintintjintintID = curEnv->GetStaticMethodID(cls, "setPopupMenuParent", "(II)V" ) ;
1337 if (voidsetPopupMenuParentjintintjintintID == NULL) {
1338 throw GiwsException::JniMethodNotFoundException(curEnv, "setPopupMenuParent");
1339 }
1340
1341                          curEnv->CallStaticVoidMethod(cls, voidsetPopupMenuParentjintintjintintID ,parentID, objID);
1342                         curEnv->DeleteLocalRef(cls);
1343 if (curEnv->ExceptionCheck()) {
1344 throw GiwsException::JniCallMethodException(curEnv);
1345 }
1346 }
1347
1348 void CallScilabBridge::removePopupMenuFromParent (JavaVM * jvm_, int parentID, int objID){
1349
1350 JNIEnv * curEnv = NULL;
1351 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1352 jclass cls = curEnv->FindClass( className().c_str() );
1353
1354 jmethodID voidremovePopupMenuFromParentjintintjintintID = curEnv->GetStaticMethodID(cls, "removePopupMenuFromParent", "(II)V" ) ;
1355 if (voidremovePopupMenuFromParentjintintjintintID == NULL) {
1356 throw GiwsException::JniMethodNotFoundException(curEnv, "removePopupMenuFromParent");
1357 }
1358
1359                          curEnv->CallStaticVoidMethod(cls, voidremovePopupMenuFromParentjintintjintintID ,parentID, objID);
1360                         curEnv->DeleteLocalRef(cls);
1361 if (curEnv->ExceptionCheck()) {
1362 throw GiwsException::JniCallMethodException(curEnv);
1363 }
1364 }
1365
1366 void CallScilabBridge::setListBoxParent (JavaVM * jvm_, int parentID, int objID){
1367
1368 JNIEnv * curEnv = NULL;
1369 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1370 jclass cls = curEnv->FindClass( className().c_str() );
1371
1372 jmethodID voidsetListBoxParentjintintjintintID = curEnv->GetStaticMethodID(cls, "setListBoxParent", "(II)V" ) ;
1373 if (voidsetListBoxParentjintintjintintID == NULL) {
1374 throw GiwsException::JniMethodNotFoundException(curEnv, "setListBoxParent");
1375 }
1376
1377                          curEnv->CallStaticVoidMethod(cls, voidsetListBoxParentjintintjintintID ,parentID, objID);
1378                         curEnv->DeleteLocalRef(cls);
1379 if (curEnv->ExceptionCheck()) {
1380 throw GiwsException::JniCallMethodException(curEnv);
1381 }
1382 }
1383
1384 void CallScilabBridge::removeListBoxFromParent (JavaVM * jvm_, int parentID, int objID){
1385
1386 JNIEnv * curEnv = NULL;
1387 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1388 jclass cls = curEnv->FindClass( className().c_str() );
1389
1390 jmethodID voidremoveListBoxFromParentjintintjintintID = curEnv->GetStaticMethodID(cls, "removeListBoxFromParent", "(II)V" ) ;
1391 if (voidremoveListBoxFromParentjintintjintintID == NULL) {
1392 throw GiwsException::JniMethodNotFoundException(curEnv, "removeListBoxFromParent");
1393 }
1394
1395                          curEnv->CallStaticVoidMethod(cls, voidremoveListBoxFromParentjintintjintintID ,parentID, objID);
1396                         curEnv->DeleteLocalRef(cls);
1397 if (curEnv->ExceptionCheck()) {
1398 throw GiwsException::JniCallMethodException(curEnv);
1399 }
1400 }
1401
1402 void CallScilabBridge::setFrameParent (JavaVM * jvm_, int parentID, int objID){
1403
1404 JNIEnv * curEnv = NULL;
1405 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1406 jclass cls = curEnv->FindClass( className().c_str() );
1407
1408 jmethodID voidsetFrameParentjintintjintintID = curEnv->GetStaticMethodID(cls, "setFrameParent", "(II)V" ) ;
1409 if (voidsetFrameParentjintintjintintID == NULL) {
1410 throw GiwsException::JniMethodNotFoundException(curEnv, "setFrameParent");
1411 }
1412
1413                          curEnv->CallStaticVoidMethod(cls, voidsetFrameParentjintintjintintID ,parentID, objID);
1414                         curEnv->DeleteLocalRef(cls);
1415 if (curEnv->ExceptionCheck()) {
1416 throw GiwsException::JniCallMethodException(curEnv);
1417 }
1418 }
1419
1420 void CallScilabBridge::removeFrameFromParent (JavaVM * jvm_, int parentID, int objID){
1421
1422 JNIEnv * curEnv = NULL;
1423 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1424 jclass cls = curEnv->FindClass( className().c_str() );
1425
1426 jmethodID voidremoveFrameFromParentjintintjintintID = curEnv->GetStaticMethodID(cls, "removeFrameFromParent", "(II)V" ) ;
1427 if (voidremoveFrameFromParentjintintjintintID == NULL) {
1428 throw GiwsException::JniMethodNotFoundException(curEnv, "removeFrameFromParent");
1429 }
1430
1431                          curEnv->CallStaticVoidMethod(cls, voidremoveFrameFromParentjintintjintintID ,parentID, objID);
1432                         curEnv->DeleteLocalRef(cls);
1433 if (curEnv->ExceptionCheck()) {
1434 throw GiwsException::JniCallMethodException(curEnv);
1435 }
1436 }
1437
1438 void CallScilabBridge::setWidgetText (JavaVM * jvm_, int objID, char const* text){
1439
1440 JNIEnv * curEnv = NULL;
1441 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1442 jclass cls = curEnv->FindClass( className().c_str() );
1443
1444 jmethodID voidsetWidgetTextjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setWidgetText", "(ILjava/lang/String;)V" ) ;
1445 if (voidsetWidgetTextjintintjstringjava_lang_StringID == NULL) {
1446 throw GiwsException::JniMethodNotFoundException(curEnv, "setWidgetText");
1447 }
1448
1449 jstring text_ = curEnv->NewStringUTF( text );
1450 if (text != NULL && text_ == NULL)
1451 {
1452 throw GiwsException::JniBadAllocException(curEnv);
1453 }
1454
1455
1456                          curEnv->CallStaticVoidMethod(cls, voidsetWidgetTextjintintjstringjava_lang_StringID ,objID, text_);
1457                         curEnv->DeleteLocalRef(text_);
1458 curEnv->DeleteLocalRef(cls);
1459 if (curEnv->ExceptionCheck()) {
1460 throw GiwsException::JniCallMethodException(curEnv);
1461 }
1462 }
1463
1464 char* CallScilabBridge::getWidgetText (JavaVM * jvm_, int objID){
1465
1466 JNIEnv * curEnv = NULL;
1467 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1468 jclass cls = curEnv->FindClass( className().c_str() );
1469
1470 jmethodID jstringgetWidgetTextjintintID = curEnv->GetStaticMethodID(cls, "getWidgetText", "(I)Ljava/lang/String;" ) ;
1471 if (jstringgetWidgetTextjintintID == NULL) {
1472 throw GiwsException::JniMethodNotFoundException(curEnv, "getWidgetText");
1473 }
1474
1475                         jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringgetWidgetTextjintintID ,objID));
1476                         if (curEnv->ExceptionCheck()) {
1477 throw GiwsException::JniCallMethodException(curEnv);
1478 }
1479
1480 const char *tempString = curEnv->GetStringUTFChars(res, 0);
1481 char * myStringBuffer = new char[strlen(tempString) + 1];
1482 strcpy(myStringBuffer, tempString);
1483 curEnv->ReleaseStringUTFChars(res, tempString);
1484 curEnv->DeleteLocalRef(res);
1485 curEnv->DeleteLocalRef(cls);
1486 if (curEnv->ExceptionCheck()) {
1487 delete[] myStringBuffer;
1488                                 throw GiwsException::JniCallMethodException(curEnv);
1489 }
1490 return myStringBuffer;
1491
1492 }
1493
1494 void CallScilabBridge::setFrameText (JavaVM * jvm_, int objID, char const* text){
1495
1496 JNIEnv * curEnv = NULL;
1497 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1498 jclass cls = curEnv->FindClass( className().c_str() );
1499
1500 jmethodID voidsetFrameTextjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setFrameText", "(ILjava/lang/String;)V" ) ;
1501 if (voidsetFrameTextjintintjstringjava_lang_StringID == NULL) {
1502 throw GiwsException::JniMethodNotFoundException(curEnv, "setFrameText");
1503 }
1504
1505 jstring text_ = curEnv->NewStringUTF( text );
1506 if (text != NULL && text_ == NULL)
1507 {
1508 throw GiwsException::JniBadAllocException(curEnv);
1509 }
1510
1511
1512                          curEnv->CallStaticVoidMethod(cls, voidsetFrameTextjintintjstringjava_lang_StringID ,objID, text_);
1513                         curEnv->DeleteLocalRef(text_);
1514 curEnv->DeleteLocalRef(cls);
1515 if (curEnv->ExceptionCheck()) {
1516 throw GiwsException::JniCallMethodException(curEnv);
1517 }
1518 }
1519
1520 char* CallScilabBridge::getFrameText (JavaVM * jvm_, int objID){
1521
1522 JNIEnv * curEnv = NULL;
1523 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1524 jclass cls = curEnv->FindClass( className().c_str() );
1525
1526 jmethodID jstringgetFrameTextjintintID = curEnv->GetStaticMethodID(cls, "getFrameText", "(I)Ljava/lang/String;" ) ;
1527 if (jstringgetFrameTextjintintID == NULL) {
1528 throw GiwsException::JniMethodNotFoundException(curEnv, "getFrameText");
1529 }
1530
1531                         jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringgetFrameTextjintintID ,objID));
1532                         if (curEnv->ExceptionCheck()) {
1533 throw GiwsException::JniCallMethodException(curEnv);
1534 }
1535
1536 const char *tempString = curEnv->GetStringUTFChars(res, 0);
1537 char * myStringBuffer = new char[strlen(tempString) + 1];
1538 strcpy(myStringBuffer, tempString);
1539 curEnv->ReleaseStringUTFChars(res, tempString);
1540 curEnv->DeleteLocalRef(res);
1541 curEnv->DeleteLocalRef(cls);
1542 if (curEnv->ExceptionCheck()) {
1543 delete[] myStringBuffer;
1544                                 throw GiwsException::JniCallMethodException(curEnv);
1545 }
1546 return myStringBuffer;
1547
1548 }
1549
1550 void CallScilabBridge::setWidgetBackgroundColor (JavaVM * jvm_, int objID, int red, int green, int blue){
1551
1552 JNIEnv * curEnv = NULL;
1553 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1554 jclass cls = curEnv->FindClass( className().c_str() );
1555
1556 jmethodID voidsetWidgetBackgroundColorjintintjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "setWidgetBackgroundColor", "(IIII)V" ) ;
1557 if (voidsetWidgetBackgroundColorjintintjintintjintintjintintID == NULL) {
1558 throw GiwsException::JniMethodNotFoundException(curEnv, "setWidgetBackgroundColor");
1559 }
1560
1561                          curEnv->CallStaticVoidMethod(cls, voidsetWidgetBackgroundColorjintintjintintjintintjintintID ,objID, red, green, blue);
1562                         curEnv->DeleteLocalRef(cls);
1563 if (curEnv->ExceptionCheck()) {
1564 throw GiwsException::JniCallMethodException(curEnv);
1565 }
1566 }
1567
1568 int* CallScilabBridge::getWidgetBackgroundColor (JavaVM * jvm_, int objID){
1569
1570 JNIEnv * curEnv = NULL;
1571 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1572 jclass cls = curEnv->FindClass( className().c_str() );
1573
1574 jmethodID jintArray_getWidgetBackgroundColorjintintID = curEnv->GetStaticMethodID(cls, "getWidgetBackgroundColor", "(I)[I" ) ;
1575 if (jintArray_getWidgetBackgroundColorjintintID == NULL) {
1576 throw GiwsException::JniMethodNotFoundException(curEnv, "getWidgetBackgroundColor");
1577 }
1578
1579                         jintArray res =  static_cast<jintArray>( curEnv->CallStaticObjectMethod(cls, jintArray_getWidgetBackgroundColorjintintID ,objID));
1580                         if (res == NULL) { return NULL; }
1581                         if (curEnv->ExceptionCheck()) {
1582 throw GiwsException::JniCallMethodException(curEnv);
1583 }int lenRow;
1584  lenRow = curEnv->GetArrayLength(res);
1585 jboolean isCopy = JNI_FALSE;
1586
1587 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
1588 jint *resultsArray = static_cast<jint *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
1589 int* myArray= new int[ lenRow];
1590
1591 for (jsize i = 0; i <  lenRow; i++){
1592 myArray[i]=resultsArray[i];
1593 }
1594 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
1595
1596                         curEnv->DeleteLocalRef(res);
1597 curEnv->DeleteLocalRef(cls);
1598 if (curEnv->ExceptionCheck()) {
1599 delete[] myArray;
1600                                 throw GiwsException::JniCallMethodException(curEnv);
1601 }
1602 return myArray;
1603
1604 }
1605
1606 void CallScilabBridge::setWidgetForegroundColor (JavaVM * jvm_, int objID, int red, int green, int blue){
1607
1608 JNIEnv * curEnv = NULL;
1609 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1610 jclass cls = curEnv->FindClass( className().c_str() );
1611
1612 jmethodID voidsetWidgetForegroundColorjintintjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "setWidgetForegroundColor", "(IIII)V" ) ;
1613 if (voidsetWidgetForegroundColorjintintjintintjintintjintintID == NULL) {
1614 throw GiwsException::JniMethodNotFoundException(curEnv, "setWidgetForegroundColor");
1615 }
1616
1617                          curEnv->CallStaticVoidMethod(cls, voidsetWidgetForegroundColorjintintjintintjintintjintintID ,objID, red, green, blue);
1618                         curEnv->DeleteLocalRef(cls);
1619 if (curEnv->ExceptionCheck()) {
1620 throw GiwsException::JniCallMethodException(curEnv);
1621 }
1622 }
1623
1624 int* CallScilabBridge::getWidgetForegroundColor (JavaVM * jvm_, int objID){
1625
1626 JNIEnv * curEnv = NULL;
1627 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1628 jclass cls = curEnv->FindClass( className().c_str() );
1629
1630 jmethodID jintArray_getWidgetForegroundColorjintintID = curEnv->GetStaticMethodID(cls, "getWidgetForegroundColor", "(I)[I" ) ;
1631 if (jintArray_getWidgetForegroundColorjintintID == NULL) {
1632 throw GiwsException::JniMethodNotFoundException(curEnv, "getWidgetForegroundColor");
1633 }
1634
1635                         jintArray res =  static_cast<jintArray>( curEnv->CallStaticObjectMethod(cls, jintArray_getWidgetForegroundColorjintintID ,objID));
1636                         if (res == NULL) { return NULL; }
1637                         if (curEnv->ExceptionCheck()) {
1638 throw GiwsException::JniCallMethodException(curEnv);
1639 }int lenRow;
1640  lenRow = curEnv->GetArrayLength(res);
1641 jboolean isCopy = JNI_FALSE;
1642
1643 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
1644 jint *resultsArray = static_cast<jint *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
1645 int* myArray= new int[ lenRow];
1646
1647 for (jsize i = 0; i <  lenRow; i++){
1648 myArray[i]=resultsArray[i];
1649 }
1650 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
1651
1652                         curEnv->DeleteLocalRef(res);
1653 curEnv->DeleteLocalRef(cls);
1654 if (curEnv->ExceptionCheck()) {
1655 delete[] myArray;
1656                                 throw GiwsException::JniCallMethodException(curEnv);
1657 }
1658 return myArray;
1659
1660 }
1661
1662 void CallScilabBridge::setFrameBackgroundColor (JavaVM * jvm_, int objID, int red, int green, int blue){
1663
1664 JNIEnv * curEnv = NULL;
1665 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1666 jclass cls = curEnv->FindClass( className().c_str() );
1667
1668 jmethodID voidsetFrameBackgroundColorjintintjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "setFrameBackgroundColor", "(IIII)V" ) ;
1669 if (voidsetFrameBackgroundColorjintintjintintjintintjintintID == NULL) {
1670 throw GiwsException::JniMethodNotFoundException(curEnv, "setFrameBackgroundColor");
1671 }
1672
1673                          curEnv->CallStaticVoidMethod(cls, voidsetFrameBackgroundColorjintintjintintjintintjintintID ,objID, red, green, blue);
1674                         curEnv->DeleteLocalRef(cls);
1675 if (curEnv->ExceptionCheck()) {
1676 throw GiwsException::JniCallMethodException(curEnv);
1677 }
1678 }
1679
1680 int* CallScilabBridge::getFrameBackgroundColor (JavaVM * jvm_, int objID){
1681
1682 JNIEnv * curEnv = NULL;
1683 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1684 jclass cls = curEnv->FindClass( className().c_str() );
1685
1686 jmethodID jintArray_getFrameBackgroundColorjintintID = curEnv->GetStaticMethodID(cls, "getFrameBackgroundColor", "(I)[I" ) ;
1687 if (jintArray_getFrameBackgroundColorjintintID == NULL) {
1688 throw GiwsException::JniMethodNotFoundException(curEnv, "getFrameBackgroundColor");
1689 }
1690
1691                         jintArray res =  static_cast<jintArray>( curEnv->CallStaticObjectMethod(cls, jintArray_getFrameBackgroundColorjintintID ,objID));
1692                         if (res == NULL) { return NULL; }
1693                         if (curEnv->ExceptionCheck()) {
1694 throw GiwsException::JniCallMethodException(curEnv);
1695 }int lenRow;
1696  lenRow = curEnv->GetArrayLength(res);
1697 jboolean isCopy = JNI_FALSE;
1698
1699 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
1700 jint *resultsArray = static_cast<jint *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
1701 int* myArray= new int[ lenRow];
1702
1703 for (jsize i = 0; i <  lenRow; i++){
1704 myArray[i]=resultsArray[i];
1705 }
1706 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
1707
1708                         curEnv->DeleteLocalRef(res);
1709 curEnv->DeleteLocalRef(cls);
1710 if (curEnv->ExceptionCheck()) {
1711 delete[] myArray;
1712                                 throw GiwsException::JniCallMethodException(curEnv);
1713 }
1714 return myArray;
1715
1716 }
1717
1718 void CallScilabBridge::setFrameForegroundColor (JavaVM * jvm_, int objID, int red, int green, int blue){
1719
1720 JNIEnv * curEnv = NULL;
1721 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1722 jclass cls = curEnv->FindClass( className().c_str() );
1723
1724 jmethodID voidsetFrameForegroundColorjintintjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "setFrameForegroundColor", "(IIII)V" ) ;
1725 if (voidsetFrameForegroundColorjintintjintintjintintjintintID == NULL) {
1726 throw GiwsException::JniMethodNotFoundException(curEnv, "setFrameForegroundColor");
1727 }
1728
1729                          curEnv->CallStaticVoidMethod(cls, voidsetFrameForegroundColorjintintjintintjintintjintintID ,objID, red, green, blue);
1730                         curEnv->DeleteLocalRef(cls);
1731 if (curEnv->ExceptionCheck()) {
1732 throw GiwsException::JniCallMethodException(curEnv);
1733 }
1734 }
1735
1736 int* CallScilabBridge::getFrameForegroundColor (JavaVM * jvm_, int objID){
1737
1738 JNIEnv * curEnv = NULL;
1739 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1740 jclass cls = curEnv->FindClass( className().c_str() );
1741
1742 jmethodID jintArray_getFrameForegroundColorjintintID = curEnv->GetStaticMethodID(cls, "getFrameForegroundColor", "(I)[I" ) ;
1743 if (jintArray_getFrameForegroundColorjintintID == NULL) {
1744 throw GiwsException::JniMethodNotFoundException(curEnv, "getFrameForegroundColor");
1745 }
1746
1747                         jintArray res =  static_cast<jintArray>( curEnv->CallStaticObjectMethod(cls, jintArray_getFrameForegroundColorjintintID ,objID));
1748                         if (res == NULL) { return NULL; }
1749                         if (curEnv->ExceptionCheck()) {
1750 throw GiwsException::JniCallMethodException(curEnv);
1751 }int lenRow;
1752  lenRow = curEnv->GetArrayLength(res);
1753 jboolean isCopy = JNI_FALSE;
1754
1755 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
1756 jint *resultsArray = static_cast<jint *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
1757 int* myArray= new int[ lenRow];
1758
1759 for (jsize i = 0; i <  lenRow; i++){
1760 myArray[i]=resultsArray[i];
1761 }
1762 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
1763
1764                         curEnv->DeleteLocalRef(res);
1765 curEnv->DeleteLocalRef(cls);
1766 if (curEnv->ExceptionCheck()) {
1767 delete[] myArray;
1768                                 throw GiwsException::JniCallMethodException(curEnv);
1769 }
1770 return myArray;
1771
1772 }
1773
1774 void CallScilabBridge::setWidgetFontName (JavaVM * jvm_, int objID, char const* name){
1775
1776 JNIEnv * curEnv = NULL;
1777 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1778 jclass cls = curEnv->FindClass( className().c_str() );
1779
1780 jmethodID voidsetWidgetFontNamejintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setWidgetFontName", "(ILjava/lang/String;)V" ) ;
1781 if (voidsetWidgetFontNamejintintjstringjava_lang_StringID == NULL) {
1782 throw GiwsException::JniMethodNotFoundException(curEnv, "setWidgetFontName");
1783 }
1784
1785 jstring name_ = curEnv->NewStringUTF( name );
1786 if (name != NULL && name_ == NULL)
1787 {
1788 throw GiwsException::JniBadAllocException(curEnv);
1789 }
1790
1791
1792                          curEnv->CallStaticVoidMethod(cls, voidsetWidgetFontNamejintintjstringjava_lang_StringID ,objID, name_);
1793                         curEnv->DeleteLocalRef(name_);
1794 curEnv->DeleteLocalRef(cls);
1795 if (curEnv->ExceptionCheck()) {
1796 throw GiwsException::JniCallMethodException(curEnv);
1797 }
1798 }
1799
1800 char* CallScilabBridge::getWidgetFontName (JavaVM * jvm_, int objID){
1801
1802 JNIEnv * curEnv = NULL;
1803 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1804 jclass cls = curEnv->FindClass( className().c_str() );
1805
1806 jmethodID jstringgetWidgetFontNamejintintID = curEnv->GetStaticMethodID(cls, "getWidgetFontName", "(I)Ljava/lang/String;" ) ;
1807 if (jstringgetWidgetFontNamejintintID == NULL) {
1808 throw GiwsException::JniMethodNotFoundException(curEnv, "getWidgetFontName");
1809 }
1810
1811                         jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringgetWidgetFontNamejintintID ,objID));
1812                         if (curEnv->ExceptionCheck()) {
1813 throw GiwsException::JniCallMethodException(curEnv);
1814 }
1815
1816 const char *tempString = curEnv->GetStringUTFChars(res, 0);
1817 char * myStringBuffer = new char[strlen(tempString) + 1];
1818 strcpy(myStringBuffer, tempString);
1819 curEnv->ReleaseStringUTFChars(res, tempString);
1820 curEnv->DeleteLocalRef(res);
1821 curEnv->DeleteLocalRef(cls);
1822 if (curEnv->ExceptionCheck()) {
1823 delete[] myStringBuffer;
1824                                 throw GiwsException::JniCallMethodException(curEnv);
1825 }
1826 return myStringBuffer;
1827
1828 }
1829
1830 void CallScilabBridge::setWidgetFontWeight (JavaVM * jvm_, int objID, char const* weight){
1831
1832 JNIEnv * curEnv = NULL;
1833 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1834 jclass cls = curEnv->FindClass( className().c_str() );
1835
1836 jmethodID voidsetWidgetFontWeightjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setWidgetFontWeight", "(ILjava/lang/String;)V" ) ;
1837 if (voidsetWidgetFontWeightjintintjstringjava_lang_StringID == NULL) {
1838 throw GiwsException::JniMethodNotFoundException(curEnv, "setWidgetFontWeight");
1839 }
1840
1841 jstring weight_ = curEnv->NewStringUTF( weight );
1842 if (weight != NULL && weight_ == NULL)
1843 {
1844 throw GiwsException::JniBadAllocException(curEnv);
1845 }
1846
1847
1848                          curEnv->CallStaticVoidMethod(cls, voidsetWidgetFontWeightjintintjstringjava_lang_StringID ,objID, weight_);
1849                         curEnv->DeleteLocalRef(weight_);
1850 curEnv->DeleteLocalRef(cls);
1851 if (curEnv->ExceptionCheck()) {
1852 throw GiwsException::JniCallMethodException(curEnv);
1853 }
1854 }
1855
1856 void CallScilabBridge::setWidgetFontSize (JavaVM * jvm_, int objID, int size){
1857
1858 JNIEnv * curEnv = NULL;
1859 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1860 jclass cls = curEnv->FindClass( className().c_str() );
1861
1862 jmethodID voidsetWidgetFontSizejintintjintintID = curEnv->GetStaticMethodID(cls, "setWidgetFontSize", "(II)V" ) ;
1863 if (voidsetWidgetFontSizejintintjintintID == NULL) {
1864 throw GiwsException::JniMethodNotFoundException(curEnv, "setWidgetFontSize");
1865 }
1866
1867                          curEnv->CallStaticVoidMethod(cls, voidsetWidgetFontSizejintintjintintID ,objID, size);
1868                         curEnv->DeleteLocalRef(cls);
1869 if (curEnv->ExceptionCheck()) {
1870 throw GiwsException::JniCallMethodException(curEnv);
1871 }
1872 }
1873
1874 int CallScilabBridge::getWidgetFontSize (JavaVM * jvm_, int objID){
1875
1876 JNIEnv * curEnv = NULL;
1877 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1878 jclass cls = curEnv->FindClass( className().c_str() );
1879
1880 jmethodID jintgetWidgetFontSizejintintID = curEnv->GetStaticMethodID(cls, "getWidgetFontSize", "(I)I" ) ;
1881 if (jintgetWidgetFontSizejintintID == NULL) {
1882 throw GiwsException::JniMethodNotFoundException(curEnv, "getWidgetFontSize");
1883 }
1884
1885                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetWidgetFontSizejintintID ,objID));
1886                         curEnv->DeleteLocalRef(cls);
1887 if (curEnv->ExceptionCheck()) {
1888 throw GiwsException::JniCallMethodException(curEnv);
1889 }
1890 return res;
1891
1892 }
1893
1894 void CallScilabBridge::setWidgetFontAngle (JavaVM * jvm_, int objID, char const* angle){
1895
1896 JNIEnv * curEnv = NULL;
1897 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1898 jclass cls = curEnv->FindClass( className().c_str() );
1899
1900 jmethodID voidsetWidgetFontAnglejintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setWidgetFontAngle", "(ILjava/lang/String;)V" ) ;
1901 if (voidsetWidgetFontAnglejintintjstringjava_lang_StringID == NULL) {
1902 throw GiwsException::JniMethodNotFoundException(curEnv, "setWidgetFontAngle");
1903 }
1904
1905 jstring angle_ = curEnv->NewStringUTF( angle );
1906 if (angle != NULL && angle_ == NULL)
1907 {
1908 throw GiwsException::JniBadAllocException(curEnv);
1909 }
1910
1911
1912                          curEnv->CallStaticVoidMethod(cls, voidsetWidgetFontAnglejintintjstringjava_lang_StringID ,objID, angle_);
1913                         curEnv->DeleteLocalRef(angle_);
1914 curEnv->DeleteLocalRef(cls);
1915 if (curEnv->ExceptionCheck()) {
1916 throw GiwsException::JniCallMethodException(curEnv);
1917 }
1918 }
1919
1920 void CallScilabBridge::setFrameFontName (JavaVM * jvm_, int objID, char const* name){
1921
1922 JNIEnv * curEnv = NULL;
1923 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1924 jclass cls = curEnv->FindClass( className().c_str() );
1925
1926 jmethodID voidsetFrameFontNamejintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setFrameFontName", "(ILjava/lang/String;)V" ) ;
1927 if (voidsetFrameFontNamejintintjstringjava_lang_StringID == NULL) {
1928 throw GiwsException::JniMethodNotFoundException(curEnv, "setFrameFontName");
1929 }
1930
1931 jstring name_ = curEnv->NewStringUTF( name );
1932 if (name != NULL && name_ == NULL)
1933 {
1934 throw GiwsException::JniBadAllocException(curEnv);
1935 }
1936
1937
1938                          curEnv->CallStaticVoidMethod(cls, voidsetFrameFontNamejintintjstringjava_lang_StringID ,objID, name_);
1939                         curEnv->DeleteLocalRef(name_);
1940 curEnv->DeleteLocalRef(cls);
1941 if (curEnv->ExceptionCheck()) {
1942 throw GiwsException::JniCallMethodException(curEnv);
1943 }
1944 }
1945
1946 char* CallScilabBridge::getFrameFontName (JavaVM * jvm_, int objID){
1947
1948 JNIEnv * curEnv = NULL;
1949 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1950 jclass cls = curEnv->FindClass( className().c_str() );
1951
1952 jmethodID jstringgetFrameFontNamejintintID = curEnv->GetStaticMethodID(cls, "getFrameFontName", "(I)Ljava/lang/String;" ) ;
1953 if (jstringgetFrameFontNamejintintID == NULL) {
1954 throw GiwsException::JniMethodNotFoundException(curEnv, "getFrameFontName");
1955 }
1956
1957                         jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringgetFrameFontNamejintintID ,objID));
1958                         if (curEnv->ExceptionCheck()) {
1959 throw GiwsException::JniCallMethodException(curEnv);
1960 }
1961
1962 const char *tempString = curEnv->GetStringUTFChars(res, 0);
1963 char * myStringBuffer = new char[strlen(tempString) + 1];
1964 strcpy(myStringBuffer, tempString);
1965 curEnv->ReleaseStringUTFChars(res, tempString);
1966 curEnv->DeleteLocalRef(res);
1967 curEnv->DeleteLocalRef(cls);
1968 if (curEnv->ExceptionCheck()) {
1969 delete[] myStringBuffer;
1970                                 throw GiwsException::JniCallMethodException(curEnv);
1971 }
1972 return myStringBuffer;
1973
1974 }
1975
1976 void CallScilabBridge::setFrameFontWeight (JavaVM * jvm_, int objID, char const* weight){
1977
1978 JNIEnv * curEnv = NULL;
1979 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1980 jclass cls = curEnv->FindClass( className().c_str() );
1981
1982 jmethodID voidsetFrameFontWeightjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setFrameFontWeight", "(ILjava/lang/String;)V" ) ;
1983 if (voidsetFrameFontWeightjintintjstringjava_lang_StringID == NULL) {
1984 throw GiwsException::JniMethodNotFoundException(curEnv, "setFrameFontWeight");
1985 }
1986
1987 jstring weight_ = curEnv->NewStringUTF( weight );
1988 if (weight != NULL && weight_ == NULL)
1989 {
1990 throw GiwsException::JniBadAllocException(curEnv);
1991 }
1992
1993
1994                          curEnv->CallStaticVoidMethod(cls, voidsetFrameFontWeightjintintjstringjava_lang_StringID ,objID, weight_);
1995                         curEnv->DeleteLocalRef(weight_);
1996 curEnv->DeleteLocalRef(cls);
1997 if (curEnv->ExceptionCheck()) {
1998 throw GiwsException::JniCallMethodException(curEnv);
1999 }
2000 }
2001
2002 void CallScilabBridge::setFrameFontSize (JavaVM * jvm_, int objID, int size){
2003
2004 JNIEnv * curEnv = NULL;
2005 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2006 jclass cls = curEnv->FindClass( className().c_str() );
2007
2008 jmethodID voidsetFrameFontSizejintintjintintID = curEnv->GetStaticMethodID(cls, "setFrameFontSize", "(II)V" ) ;
2009 if (voidsetFrameFontSizejintintjintintID == NULL) {
2010 throw GiwsException::JniMethodNotFoundException(curEnv, "setFrameFontSize");
2011 }
2012
2013                          curEnv->CallStaticVoidMethod(cls, voidsetFrameFontSizejintintjintintID ,objID, size);
2014                         curEnv->DeleteLocalRef(cls);
2015 if (curEnv->ExceptionCheck()) {
2016 throw GiwsException::JniCallMethodException(curEnv);
2017 }
2018 }
2019
2020 int CallScilabBridge::getFrameFontSize (JavaVM * jvm_, int objID){
2021
2022 JNIEnv * curEnv = NULL;
2023 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2024 jclass cls = curEnv->FindClass( className().c_str() );
2025
2026 jmethodID jintgetFrameFontSizejintintID = curEnv->GetStaticMethodID(cls, "getFrameFontSize", "(I)I" ) ;
2027 if (jintgetFrameFontSizejintintID == NULL) {
2028 throw GiwsException::JniMethodNotFoundException(curEnv, "getFrameFontSize");
2029 }
2030
2031                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetFrameFontSizejintintID ,objID));
2032                         curEnv->DeleteLocalRef(cls);
2033 if (curEnv->ExceptionCheck()) {
2034 throw GiwsException::JniCallMethodException(curEnv);
2035 }
2036 return res;
2037
2038 }
2039
2040 void CallScilabBridge::setFrameFontAngle (JavaVM * jvm_, int objID, char const* angle){
2041
2042 JNIEnv * curEnv = NULL;
2043 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2044 jclass cls = curEnv->FindClass( className().c_str() );
2045
2046 jmethodID voidsetFrameFontAnglejintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setFrameFontAngle", "(ILjava/lang/String;)V" ) ;
2047 if (voidsetFrameFontAnglejintintjstringjava_lang_StringID == NULL) {
2048 throw GiwsException::JniMethodNotFoundException(curEnv, "setFrameFontAngle");
2049 }
2050
2051 jstring angle_ = curEnv->NewStringUTF( angle );
2052 if (angle != NULL && angle_ == NULL)
2053 {
2054 throw GiwsException::JniBadAllocException(curEnv);
2055 }
2056
2057
2058                          curEnv->CallStaticVoidMethod(cls, voidsetFrameFontAnglejintintjstringjava_lang_StringID ,objID, angle_);
2059                         curEnv->DeleteLocalRef(angle_);
2060 curEnv->DeleteLocalRef(cls);
2061 if (curEnv->ExceptionCheck()) {
2062 throw GiwsException::JniCallMethodException(curEnv);
2063 }
2064 }
2065
2066 void CallScilabBridge::setWidgetPosition (JavaVM * jvm_, int objID, int x, int y, int width, int height){
2067
2068 JNIEnv * curEnv = NULL;
2069 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2070 jclass cls = curEnv->FindClass( className().c_str() );
2071
2072 jmethodID voidsetWidgetPositionjintintjintintjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "setWidgetPosition", "(IIIII)V" ) ;
2073 if (voidsetWidgetPositionjintintjintintjintintjintintjintintID == NULL) {
2074 throw GiwsException::JniMethodNotFoundException(curEnv, "setWidgetPosition");
2075 }
2076
2077                          curEnv->CallStaticVoidMethod(cls, voidsetWidgetPositionjintintjintintjintintjintintjintintID ,objID, x, y, width, height);
2078                         curEnv->DeleteLocalRef(cls);
2079 if (curEnv->ExceptionCheck()) {
2080 throw GiwsException::JniCallMethodException(curEnv);
2081 }
2082 }
2083
2084 int* CallScilabBridge::getWidgetPosition (JavaVM * jvm_, int objID){
2085
2086 JNIEnv * curEnv = NULL;
2087 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2088 jclass cls = curEnv->FindClass( className().c_str() );
2089
2090 jmethodID jintArray_getWidgetPositionjintintID = curEnv->GetStaticMethodID(cls, "getWidgetPosition", "(I)[I" ) ;
2091 if (jintArray_getWidgetPositionjintintID == NULL) {
2092 throw GiwsException::JniMethodNotFoundException(curEnv, "getWidgetPosition");
2093 }
2094
2095                         jintArray res =  static_cast<jintArray>( curEnv->CallStaticObjectMethod(cls, jintArray_getWidgetPositionjintintID ,objID));
2096                         if (res == NULL) { return NULL; }
2097                         if (curEnv->ExceptionCheck()) {
2098 throw GiwsException::JniCallMethodException(curEnv);
2099 }int lenRow;
2100  lenRow = curEnv->GetArrayLength(res);
2101 jboolean isCopy = JNI_FALSE;
2102
2103 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
2104 jint *resultsArray = static_cast<jint *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
2105 int* myArray= new int[ lenRow];
2106
2107 for (jsize i = 0; i <  lenRow; i++){
2108 myArray[i]=resultsArray[i];
2109 }
2110 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
2111
2112                         curEnv->DeleteLocalRef(res);
2113 curEnv->DeleteLocalRef(cls);
2114 if (curEnv->ExceptionCheck()) {
2115 delete[] myArray;
2116                                 throw GiwsException::JniCallMethodException(curEnv);
2117 }
2118 return myArray;
2119
2120 }
2121
2122 void CallScilabBridge::setFramePosition (JavaVM * jvm_, int objID, int x, int y, int width, int height){
2123
2124 JNIEnv * curEnv = NULL;
2125 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2126 jclass cls = curEnv->FindClass( className().c_str() );
2127
2128 jmethodID voidsetFramePositionjintintjintintjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "setFramePosition", "(IIIII)V" ) ;
2129 if (voidsetFramePositionjintintjintintjintintjintintjintintID == NULL) {
2130 throw GiwsException::JniMethodNotFoundException(curEnv, "setFramePosition");
2131 }
2132
2133                          curEnv->CallStaticVoidMethod(cls, voidsetFramePositionjintintjintintjintintjintintjintintID ,objID, x, y, width, height);
2134                         curEnv->DeleteLocalRef(cls);
2135 if (curEnv->ExceptionCheck()) {
2136 throw GiwsException::JniCallMethodException(curEnv);
2137 }
2138 }
2139
2140 int* CallScilabBridge::getFramePosition (JavaVM * jvm_, int objID){
2141
2142 JNIEnv * curEnv = NULL;
2143 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2144 jclass cls = curEnv->FindClass( className().c_str() );
2145
2146 jmethodID jintArray_getFramePositionjintintID = curEnv->GetStaticMethodID(cls, "getFramePosition", "(I)[I" ) ;
2147 if (jintArray_getFramePositionjintintID == NULL) {
2148 throw GiwsException::JniMethodNotFoundException(curEnv, "getFramePosition");
2149 }
2150
2151                         jintArray res =  static_cast<jintArray>( curEnv->CallStaticObjectMethod(cls, jintArray_getFramePositionjintintID ,objID));
2152                         if (res == NULL) { return NULL; }
2153                         if (curEnv->ExceptionCheck()) {
2154 throw GiwsException::JniCallMethodException(curEnv);
2155 }int lenRow;
2156  lenRow = curEnv->GetArrayLength(res);
2157 jboolean isCopy = JNI_FALSE;
2158
2159 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
2160 jint *resultsArray = static_cast<jint *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
2161 int* myArray= new int[ lenRow];
2162
2163 for (jsize i = 0; i <  lenRow; i++){
2164 myArray[i]=resultsArray[i];
2165 }
2166 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
2167
2168                         curEnv->DeleteLocalRef(res);
2169 curEnv->DeleteLocalRef(cls);
2170 if (curEnv->ExceptionCheck()) {
2171 delete[] myArray;
2172                                 throw GiwsException::JniCallMethodException(curEnv);
2173 }
2174 return myArray;
2175
2176 }
2177
2178 void CallScilabBridge::setWidgetCallback (JavaVM * jvm_, int objID, char const* text, int type){
2179
2180 JNIEnv * curEnv = NULL;
2181 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2182 jclass cls = curEnv->FindClass( className().c_str() );
2183
2184 jmethodID voidsetWidgetCallbackjintintjstringjava_lang_StringjintintID = curEnv->GetStaticMethodID(cls, "setWidgetCallback", "(ILjava/lang/String;I)V" ) ;
2185 if (voidsetWidgetCallbackjintintjstringjava_lang_StringjintintID == NULL) {
2186 throw GiwsException::JniMethodNotFoundException(curEnv, "setWidgetCallback");
2187 }
2188
2189 jstring text_ = curEnv->NewStringUTF( text );
2190 if (text != NULL && text_ == NULL)
2191 {
2192 throw GiwsException::JniBadAllocException(curEnv);
2193 }
2194
2195
2196                          curEnv->CallStaticVoidMethod(cls, voidsetWidgetCallbackjintintjstringjava_lang_StringjintintID ,objID, text_, type);
2197                         curEnv->DeleteLocalRef(text_);
2198 curEnv->DeleteLocalRef(cls);
2199 if (curEnv->ExceptionCheck()) {
2200 throw GiwsException::JniCallMethodException(curEnv);
2201 }
2202 }
2203
2204 void CallScilabBridge::setFrameCallback (JavaVM * jvm_, int objID, char const* text, int type){
2205
2206 JNIEnv * curEnv = NULL;
2207 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2208 jclass cls = curEnv->FindClass( className().c_str() );
2209
2210 jmethodID voidsetFrameCallbackjintintjstringjava_lang_StringjintintID = curEnv->GetStaticMethodID(cls, "setFrameCallback", "(ILjava/lang/String;I)V" ) ;
2211 if (voidsetFrameCallbackjintintjstringjava_lang_StringjintintID == NULL) {
2212 throw GiwsException::JniMethodNotFoundException(curEnv, "setFrameCallback");
2213 }
2214
2215 jstring text_ = curEnv->NewStringUTF( text );
2216 if (text != NULL && text_ == NULL)
2217 {
2218 throw GiwsException::JniBadAllocException(curEnv);
2219 }
2220
2221
2222                          curEnv->CallStaticVoidMethod(cls, voidsetFrameCallbackjintintjstringjava_lang_StringjintintID ,objID, text_, type);
2223                         curEnv->DeleteLocalRef(text_);
2224 curEnv->DeleteLocalRef(cls);
2225 if (curEnv->ExceptionCheck()) {
2226 throw GiwsException::JniCallMethodException(curEnv);
2227 }
2228 }
2229
2230 void CallScilabBridge::setWidgetHorizontalAlignment (JavaVM * jvm_, int objID, char const* alignment){
2231
2232 JNIEnv * curEnv = NULL;
2233 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2234 jclass cls = curEnv->FindClass( className().c_str() );
2235
2236 jmethodID voidsetWidgetHorizontalAlignmentjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setWidgetHorizontalAlignment", "(ILjava/lang/String;)V" ) ;
2237 if (voidsetWidgetHorizontalAlignmentjintintjstringjava_lang_StringID == NULL) {
2238 throw GiwsException::JniMethodNotFoundException(curEnv, "setWidgetHorizontalAlignment");
2239 }
2240
2241 jstring alignment_ = curEnv->NewStringUTF( alignment );
2242 if (alignment != NULL && alignment_ == NULL)
2243 {
2244 throw GiwsException::JniBadAllocException(curEnv);
2245 }
2246
2247
2248                          curEnv->CallStaticVoidMethod(cls, voidsetWidgetHorizontalAlignmentjintintjstringjava_lang_StringID ,objID, alignment_);
2249                         curEnv->DeleteLocalRef(alignment_);
2250 curEnv->DeleteLocalRef(cls);
2251 if (curEnv->ExceptionCheck()) {
2252 throw GiwsException::JniCallMethodException(curEnv);
2253 }
2254 }
2255
2256 void CallScilabBridge::setWidgetVerticalAlignment (JavaVM * jvm_, int objID, char const* alignment){
2257
2258 JNIEnv * curEnv = NULL;
2259 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2260 jclass cls = curEnv->FindClass( className().c_str() );
2261
2262 jmethodID voidsetWidgetVerticalAlignmentjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setWidgetVerticalAlignment", "(ILjava/lang/String;)V" ) ;
2263 if (voidsetWidgetVerticalAlignmentjintintjstringjava_lang_StringID == NULL) {
2264 throw GiwsException::JniMethodNotFoundException(curEnv, "setWidgetVerticalAlignment");
2265 }
2266
2267 jstring alignment_ = curEnv->NewStringUTF( alignment );
2268 if (alignment != NULL && alignment_ == NULL)
2269 {
2270 throw GiwsException::JniBadAllocException(curEnv);
2271 }
2272
2273
2274                          curEnv->CallStaticVoidMethod(cls, voidsetWidgetVerticalAlignmentjintintjstringjava_lang_StringID ,objID, alignment_);
2275                         curEnv->DeleteLocalRef(alignment_);
2276 curEnv->DeleteLocalRef(cls);
2277 if (curEnv->ExceptionCheck()) {
2278 throw GiwsException::JniCallMethodException(curEnv);
2279 }
2280 }
2281
2282 void CallScilabBridge::setSliderMinorTickSpacing (JavaVM * jvm_, int objID, int space){
2283
2284 JNIEnv * curEnv = NULL;
2285 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2286 jclass cls = curEnv->FindClass( className().c_str() );
2287
2288 jmethodID voidsetSliderMinorTickSpacingjintintjintintID = curEnv->GetStaticMethodID(cls, "setSliderMinorTickSpacing", "(II)V" ) ;
2289 if (voidsetSliderMinorTickSpacingjintintjintintID == NULL) {
2290 throw GiwsException::JniMethodNotFoundException(curEnv, "setSliderMinorTickSpacing");
2291 }
2292
2293                          curEnv->CallStaticVoidMethod(cls, voidsetSliderMinorTickSpacingjintintjintintID ,objID, space);
2294                         curEnv->DeleteLocalRef(cls);
2295 if (curEnv->ExceptionCheck()) {
2296 throw GiwsException::JniCallMethodException(curEnv);
2297 }
2298 }
2299
2300 void CallScilabBridge::setSliderMajorTickSpacing (JavaVM * jvm_, int objID, int space){
2301
2302 JNIEnv * curEnv = NULL;
2303 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2304 jclass cls = curEnv->FindClass( className().c_str() );
2305
2306 jmethodID voidsetSliderMajorTickSpacingjintintjintintID = curEnv->GetStaticMethodID(cls, "setSliderMajorTickSpacing", "(II)V" ) ;
2307 if (voidsetSliderMajorTickSpacingjintintjintintID == NULL) {
2308 throw GiwsException::JniMethodNotFoundException(curEnv, "setSliderMajorTickSpacing");
2309 }
2310
2311                          curEnv->CallStaticVoidMethod(cls, voidsetSliderMajorTickSpacingjintintjintintID ,objID, space);
2312                         curEnv->DeleteLocalRef(cls);
2313 if (curEnv->ExceptionCheck()) {
2314 throw GiwsException::JniCallMethodException(curEnv);
2315 }
2316 }
2317
2318 void CallScilabBridge::setListBoxSelectedIndices (JavaVM * jvm_, int objID, int const* indices, int indicesSize){
2319
2320 JNIEnv * curEnv = NULL;
2321 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2322 jclass cls = curEnv->FindClass( className().c_str() );
2323
2324 jmethodID voidsetListBoxSelectedIndicesjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "setListBoxSelectedIndices", "(I[I)V" ) ;
2325 if (voidsetListBoxSelectedIndicesjintintjintArray_intintID == NULL) {
2326 throw GiwsException::JniMethodNotFoundException(curEnv, "setListBoxSelectedIndices");
2327 }
2328
2329 jintArray indices_ = curEnv->NewIntArray( indicesSize ) ;
2330
2331 if (indices_ == NULL)
2332 {
2333 // check that allocation succeed
2334 throw GiwsException::JniBadAllocException(curEnv);
2335 }
2336
2337 curEnv->SetIntArrayRegion( indices_, 0, indicesSize, (jint*)(indices) ) ;
2338
2339
2340                          curEnv->CallStaticVoidMethod(cls, voidsetListBoxSelectedIndicesjintintjintArray_intintID ,objID, indices_);
2341                         curEnv->DeleteLocalRef(indices_);
2342 curEnv->DeleteLocalRef(cls);
2343 if (curEnv->ExceptionCheck()) {
2344 throw GiwsException::JniCallMethodException(curEnv);
2345 }
2346 }
2347
2348 int* CallScilabBridge::getListBoxSelectedIndices (JavaVM * jvm_, int objID){
2349
2350 JNIEnv * curEnv = NULL;
2351 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2352 jclass cls = curEnv->FindClass( className().c_str() );
2353
2354 jmethodID jintArray_getListBoxSelectedIndicesjintintID = curEnv->GetStaticMethodID(cls, "getListBoxSelectedIndices", "(I)[I" ) ;
2355 if (jintArray_getListBoxSelectedIndicesjintintID == NULL) {
2356 throw GiwsException::JniMethodNotFoundException(curEnv, "getListBoxSelectedIndices");
2357 }
2358
2359                         jintArray res =  static_cast<jintArray>( curEnv->CallStaticObjectMethod(cls, jintArray_getListBoxSelectedIndicesjintintID ,objID));
2360                         if (res == NULL) { return NULL; }
2361                         if (curEnv->ExceptionCheck()) {
2362 throw GiwsException::JniCallMethodException(curEnv);
2363 }int lenRow;
2364  lenRow = curEnv->GetArrayLength(res);
2365 jboolean isCopy = JNI_FALSE;
2366
2367 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
2368 jint *resultsArray = static_cast<jint *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
2369 int* myArray= new int[ lenRow];
2370
2371 for (jsize i = 0; i <  lenRow; i++){
2372 myArray[i]=resultsArray[i];
2373 }
2374 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
2375
2376                         curEnv->DeleteLocalRef(res);
2377 curEnv->DeleteLocalRef(cls);
2378 if (curEnv->ExceptionCheck()) {
2379 delete[] myArray;
2380                                 throw GiwsException::JniCallMethodException(curEnv);
2381 }
2382 return myArray;
2383
2384 }
2385
2386 int CallScilabBridge::getListBoxSelectionSize (JavaVM * jvm_, int objID){
2387
2388 JNIEnv * curEnv = NULL;
2389 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2390 jclass cls = curEnv->FindClass( className().c_str() );
2391
2392 jmethodID jintgetListBoxSelectionSizejintintID = curEnv->GetStaticMethodID(cls, "getListBoxSelectionSize", "(I)I" ) ;
2393 if (jintgetListBoxSelectionSizejintintID == NULL) {
2394 throw GiwsException::JniMethodNotFoundException(curEnv, "getListBoxSelectionSize");
2395 }
2396
2397                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetListBoxSelectionSizejintintID ,objID));
2398                         curEnv->DeleteLocalRef(cls);
2399 if (curEnv->ExceptionCheck()) {
2400 throw GiwsException::JniCallMethodException(curEnv);
2401 }
2402 return res;
2403
2404 }
2405
2406 void CallScilabBridge::setPopupMenuSelectedIndex (JavaVM * jvm_, int objID, int index){
2407
2408 JNIEnv * curEnv = NULL;
2409 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2410 jclass cls = curEnv->FindClass( className().c_str() );
2411
2412 jmethodID voidsetPopupMenuSelectedIndexjintintjintintID = curEnv->GetStaticMethodID(cls, "setPopupMenuSelectedIndex", "(II)V" ) ;
2413 if (voidsetPopupMenuSelectedIndexjintintjintintID == NULL) {
2414 throw GiwsException::JniMethodNotFoundException(curEnv, "setPopupMenuSelectedIndex");
2415 }
2416
2417                          curEnv->CallStaticVoidMethod(cls, voidsetPopupMenuSelectedIndexjintintjintintID ,objID, index);
2418                         curEnv->DeleteLocalRef(cls);
2419 if (curEnv->ExceptionCheck()) {
2420 throw GiwsException::JniCallMethodException(curEnv);
2421 }
2422 }
2423
2424 int CallScilabBridge::getPopupMenuSelectedIndex (JavaVM * jvm_, int objID){
2425
2426 JNIEnv * curEnv = NULL;
2427 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2428 jclass cls = curEnv->FindClass( className().c_str() );
2429
2430 jmethodID jintgetPopupMenuSelectedIndexjintintID = curEnv->GetStaticMethodID(cls, "getPopupMenuSelectedIndex", "(I)I" ) ;
2431 if (jintgetPopupMenuSelectedIndexjintintID == NULL) {
2432 throw GiwsException::JniMethodNotFoundException(curEnv, "getPopupMenuSelectedIndex");
2433 }
2434
2435                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetPopupMenuSelectedIndexjintintID ,objID));
2436                         curEnv->DeleteLocalRef(cls);
2437 if (curEnv->ExceptionCheck()) {
2438 throw GiwsException::JniCallMethodException(curEnv);
2439 }
2440 return res;
2441
2442 }
2443
2444 void CallScilabBridge::setSliderValue (JavaVM * jvm_, int objID, int index){
2445
2446 JNIEnv * curEnv = NULL;
2447 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2448 jclass cls = curEnv->FindClass( className().c_str() );
2449
2450 jmethodID voidsetSliderValuejintintjintintID = curEnv->GetStaticMethodID(cls, "setSliderValue", "(II)V" ) ;
2451 if (voidsetSliderValuejintintjintintID == NULL) {
2452 throw GiwsException::JniMethodNotFoundException(curEnv, "setSliderValue");
2453 }
2454
2455                          curEnv->CallStaticVoidMethod(cls, voidsetSliderValuejintintjintintID ,objID, index);
2456                         curEnv->DeleteLocalRef(cls);
2457 if (curEnv->ExceptionCheck()) {
2458 throw GiwsException::JniCallMethodException(curEnv);
2459 }
2460 }
2461
2462 int CallScilabBridge::getSliderValue (JavaVM * jvm_, int objID){
2463
2464 JNIEnv * curEnv = NULL;
2465 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2466 jclass cls = curEnv->FindClass( className().c_str() );
2467
2468 jmethodID jintgetSliderValuejintintID = curEnv->GetStaticMethodID(cls, "getSliderValue", "(I)I" ) ;
2469 if (jintgetSliderValuejintintID == NULL) {
2470 throw GiwsException::JniMethodNotFoundException(curEnv, "getSliderValue");
2471 }
2472
2473                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetSliderValuejintintID ,objID));
2474                         curEnv->DeleteLocalRef(cls);
2475 if (curEnv->ExceptionCheck()) {
2476 throw GiwsException::JniCallMethodException(curEnv);
2477 }
2478 return res;
2479
2480 }
2481
2482 void CallScilabBridge::setRadioButtonChecked (JavaVM * jvm_, int objID, bool status){
2483
2484 JNIEnv * curEnv = NULL;
2485 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2486 jclass cls = curEnv->FindClass( className().c_str() );
2487
2488 jmethodID voidsetRadioButtonCheckedjintintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "setRadioButtonChecked", "(IZ)V" ) ;
2489 if (voidsetRadioButtonCheckedjintintjbooleanbooleanID == NULL) {
2490 throw GiwsException::JniMethodNotFoundException(curEnv, "setRadioButtonChecked");
2491 }
2492
2493 jboolean status_ = (static_cast<bool>(status) ? JNI_TRUE : JNI_FALSE);
2494
2495                          curEnv->CallStaticVoidMethod(cls, voidsetRadioButtonCheckedjintintjbooleanbooleanID ,objID, status_);
2496                         curEnv->DeleteLocalRef(cls);
2497 if (curEnv->ExceptionCheck()) {
2498 throw GiwsException::JniCallMethodException(curEnv);
2499 }
2500 }
2501
2502 bool CallScilabBridge::isRadioButtonChecked (JavaVM * jvm_, int objID){
2503
2504 JNIEnv * curEnv = NULL;
2505 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2506 jclass cls = curEnv->FindClass( className().c_str() );
2507
2508 jmethodID jbooleanisRadioButtonCheckedjintintID = curEnv->GetStaticMethodID(cls, "isRadioButtonChecked", "(I)Z" ) ;
2509 if (jbooleanisRadioButtonCheckedjintintID == NULL) {
2510 throw GiwsException::JniMethodNotFoundException(curEnv, "isRadioButtonChecked");
2511 }
2512
2513                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanisRadioButtonCheckedjintintID ,objID));
2514                         curEnv->DeleteLocalRef(cls);
2515 if (curEnv->ExceptionCheck()) {
2516 throw GiwsException::JniCallMethodException(curEnv);
2517 }
2518 return (res == JNI_TRUE);
2519
2520 }
2521
2522 void CallScilabBridge::setCheckBoxChecked (JavaVM * jvm_, int objID, bool status){
2523
2524 JNIEnv * curEnv = NULL;
2525 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2526 jclass cls = curEnv->FindClass( className().c_str() );
2527
2528 jmethodID voidsetCheckBoxCheckedjintintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "setCheckBoxChecked", "(IZ)V" ) ;
2529 if (voidsetCheckBoxCheckedjintintjbooleanbooleanID == NULL) {
2530 throw GiwsException::JniMethodNotFoundException(curEnv, "setCheckBoxChecked");
2531 }
2532
2533 jboolean status_ = (static_cast<bool>(status) ? JNI_TRUE : JNI_FALSE);
2534
2535                          curEnv->CallStaticVoidMethod(cls, voidsetCheckBoxCheckedjintintjbooleanbooleanID ,objID, status_);
2536                         curEnv->DeleteLocalRef(cls);
2537 if (curEnv->ExceptionCheck()) {
2538 throw GiwsException::JniCallMethodException(curEnv);
2539 }
2540 }
2541
2542 bool CallScilabBridge::isCheckBoxChecked (JavaVM * jvm_, int objID){
2543
2544 JNIEnv * curEnv = NULL;
2545 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2546 jclass cls = curEnv->FindClass( className().c_str() );
2547
2548 jmethodID jbooleanisCheckBoxCheckedjintintID = curEnv->GetStaticMethodID(cls, "isCheckBoxChecked", "(I)Z" ) ;
2549 if (jbooleanisCheckBoxCheckedjintintID == NULL) {
2550 throw GiwsException::JniMethodNotFoundException(curEnv, "isCheckBoxChecked");
2551 }
2552
2553                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanisCheckBoxCheckedjintintID ,objID));
2554                         curEnv->DeleteLocalRef(cls);
2555 if (curEnv->ExceptionCheck()) {
2556 throw GiwsException::JniCallMethodException(curEnv);
2557 }
2558 return (res == JNI_TRUE);
2559
2560 }
2561
2562 void CallScilabBridge::setSliderMinValue (JavaVM * jvm_, int objID, int value){
2563
2564 JNIEnv * curEnv = NULL;
2565 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2566 jclass cls = curEnv->FindClass( className().c_str() );
2567
2568 jmethodID voidsetSliderMinValuejintintjintintID = curEnv->GetStaticMethodID(cls, "setSliderMinValue", "(II)V" ) ;
2569 if (voidsetSliderMinValuejintintjintintID == NULL) {
2570 throw GiwsException::JniMethodNotFoundException(curEnv, "setSliderMinValue");
2571 }
2572
2573                          curEnv->CallStaticVoidMethod(cls, voidsetSliderMinValuejintintjintintID ,objID, value);
2574                         curEnv->DeleteLocalRef(cls);
2575 if (curEnv->ExceptionCheck()) {
2576 throw GiwsException::JniCallMethodException(curEnv);
2577 }
2578 }
2579
2580 void CallScilabBridge::setSliderMaxValue (JavaVM * jvm_, int objID, int value){
2581
2582 JNIEnv * curEnv = NULL;
2583 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2584 jclass cls = curEnv->FindClass( className().c_str() );
2585
2586 jmethodID voidsetSliderMaxValuejintintjintintID = curEnv->GetStaticMethodID(cls, "setSliderMaxValue", "(II)V" ) ;
2587 if (voidsetSliderMaxValuejintintjintintID == NULL) {
2588 throw GiwsException::JniMethodNotFoundException(curEnv, "setSliderMaxValue");
2589 }
2590
2591                          curEnv->CallStaticVoidMethod(cls, voidsetSliderMaxValuejintintjintintID ,objID, value);
2592                         curEnv->DeleteLocalRef(cls);
2593 if (curEnv->ExceptionCheck()) {
2594 throw GiwsException::JniCallMethodException(curEnv);
2595 }
2596 }
2597
2598 void CallScilabBridge::setSliderVertical (JavaVM * jvm_, int objID){
2599
2600 JNIEnv * curEnv = NULL;
2601 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2602 jclass cls = curEnv->FindClass( className().c_str() );
2603
2604 jmethodID voidsetSliderVerticaljintintID = curEnv->GetStaticMethodID(cls, "setSliderVertical", "(I)V" ) ;
2605 if (voidsetSliderVerticaljintintID == NULL) {
2606 throw GiwsException::JniMethodNotFoundException(curEnv, "setSliderVertical");
2607 }
2608
2609                          curEnv->CallStaticVoidMethod(cls, voidsetSliderVerticaljintintID ,objID);
2610                         curEnv->DeleteLocalRef(cls);
2611 if (curEnv->ExceptionCheck()) {
2612 throw GiwsException::JniCallMethodException(curEnv);
2613 }
2614 }
2615
2616 void CallScilabBridge::setSliderHorizontal (JavaVM * jvm_, int objID){
2617
2618 JNIEnv * curEnv = NULL;
2619 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2620 jclass cls = curEnv->FindClass( className().c_str() );
2621
2622 jmethodID voidsetSliderHorizontaljintintID = curEnv->GetStaticMethodID(cls, "setSliderHorizontal", "(I)V" ) ;
2623 if (voidsetSliderHorizontaljintintID == NULL) {
2624 throw GiwsException::JniMethodNotFoundException(curEnv, "setSliderHorizontal");
2625 }
2626
2627                          curEnv->CallStaticVoidMethod(cls, voidsetSliderHorizontaljintintID ,objID);
2628                         curEnv->DeleteLocalRef(cls);
2629 if (curEnv->ExceptionCheck()) {
2630 throw GiwsException::JniCallMethodException(curEnv);
2631 }
2632 }
2633
2634 void CallScilabBridge::setListBoxMultipleSelectionEnabled (JavaVM * jvm_, int objID, bool status){
2635
2636 JNIEnv * curEnv = NULL;
2637 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2638 jclass cls = curEnv->FindClass( className().c_str() );
2639
2640 jmethodID voidsetListBoxMultipleSelectionEnabledjintintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "setListBoxMultipleSelectionEnabled", "(IZ)V" ) ;
2641 if (voidsetListBoxMultipleSelectionEnabledjintintjbooleanbooleanID == NULL) {
2642 throw GiwsException::JniMethodNotFoundException(curEnv, "setListBoxMultipleSelectionEnabled");
2643 }
2644
2645 jboolean status_ = (static_cast<bool>(status) ? JNI_TRUE : JNI_FALSE);
2646
2647                          curEnv->CallStaticVoidMethod(cls, voidsetListBoxMultipleSelectionEnabledjintintjbooleanbooleanID ,objID, status_);
2648                         curEnv->DeleteLocalRef(cls);
2649 if (curEnv->ExceptionCheck()) {
2650 throw GiwsException::JniCallMethodException(curEnv);
2651 }
2652 }
2653
2654 char** CallScilabBridge::getListBoxAllItemsText (JavaVM * jvm_, int objID){
2655
2656 JNIEnv * curEnv = NULL;
2657 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2658 jclass cls = curEnv->FindClass( className().c_str() );
2659
2660 jmethodID jobjectArray_getListBoxAllItemsTextjintintID = curEnv->GetStaticMethodID(cls, "getListBoxAllItemsText", "(I)[Ljava/lang/String;" ) ;
2661 if (jobjectArray_getListBoxAllItemsTextjintintID == NULL) {
2662 throw GiwsException::JniMethodNotFoundException(curEnv, "getListBoxAllItemsText");
2663 }
2664
2665                         jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray_getListBoxAllItemsTextjintintID ,objID));
2666                         if (curEnv->ExceptionCheck()) {
2667 throw GiwsException::JniCallMethodException(curEnv);
2668 }int lenRow;
2669  lenRow = curEnv->GetArrayLength(res);
2670
2671 char **arrayOfString;
2672 arrayOfString = new char *[lenRow];
2673 for (jsize i = 0; i < lenRow; i++){
2674 jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
2675 const char *tempString = curEnv->GetStringUTFChars(resString, 0);
2676 arrayOfString[i] = new char[strlen(tempString) + 1];
2677
2678 strcpy(arrayOfString[i], tempString);
2679 curEnv->ReleaseStringUTFChars(resString, tempString);
2680 curEnv->DeleteLocalRef(resString);
2681 }
2682 curEnv->DeleteLocalRef(cls);
2683 if (curEnv->ExceptionCheck()) {
2684 delete[] arrayOfString;
2685                                 throw GiwsException::JniCallMethodException(curEnv);
2686 }
2687 curEnv->DeleteLocalRef(res);
2688 return arrayOfString;
2689
2690 }
2691
2692 int CallScilabBridge::getListBoxNumberOfItems (JavaVM * jvm_, int objID){
2693
2694 JNIEnv * curEnv = NULL;
2695 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2696 jclass cls = curEnv->FindClass( className().c_str() );
2697
2698 jmethodID jintgetListBoxNumberOfItemsjintintID = curEnv->GetStaticMethodID(cls, "getListBoxNumberOfItems", "(I)I" ) ;
2699 if (jintgetListBoxNumberOfItemsjintintID == NULL) {
2700 throw GiwsException::JniMethodNotFoundException(curEnv, "getListBoxNumberOfItems");
2701 }
2702
2703                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetListBoxNumberOfItemsjintintID ,objID));
2704                         curEnv->DeleteLocalRef(cls);
2705 if (curEnv->ExceptionCheck()) {
2706 throw GiwsException::JniCallMethodException(curEnv);
2707 }
2708 return res;
2709
2710 }
2711
2712 void CallScilabBridge::setListBoxText (JavaVM * jvm_, int objID, char const* const* text, int textSize){
2713
2714 JNIEnv * curEnv = NULL;
2715 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2716 jclass cls = curEnv->FindClass( className().c_str() );
2717
2718 jmethodID voidsetListBoxTextjintintjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setListBoxText", "(I[Ljava/lang/String;)V" ) ;
2719 if (voidsetListBoxTextjintintjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
2720 throw GiwsException::JniMethodNotFoundException(curEnv, "setListBoxText");
2721 }
2722 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
2723
2724 // create java array of strings.
2725 jobjectArray text_ = curEnv->NewObjectArray( textSize, stringArrayClass, NULL);
2726 if (text_ == NULL)
2727 {
2728 throw GiwsException::JniBadAllocException(curEnv);
2729 }
2730
2731 // convert each char * to java strings and fill the java array.
2732 for ( int i = 0; i < textSize; i++)
2733 {
2734 jstring TempString = curEnv->NewStringUTF( text[i] );
2735 if (TempString == NULL)
2736 {
2737 throw GiwsException::JniBadAllocException(curEnv);
2738 }
2739
2740 curEnv->SetObjectArrayElement( text_, i, TempString);
2741
2742 // avoid keeping reference on to many strings
2743 curEnv->DeleteLocalRef(TempString);
2744 }
2745                          curEnv->CallStaticVoidMethod(cls, voidsetListBoxTextjintintjobjectArray_java_lang_Stringjava_lang_StringID ,objID, text_);
2746                         curEnv->DeleteLocalRef(stringArrayClass);
2747 curEnv->DeleteLocalRef(text_);
2748 curEnv->DeleteLocalRef(cls);
2749 if (curEnv->ExceptionCheck()) {
2750 throw GiwsException::JniCallMethodException(curEnv);
2751 }
2752 }
2753
2754 void CallScilabBridge::setListBoxListBoxTop (JavaVM * jvm_, int objID, int index){
2755
2756 JNIEnv * curEnv = NULL;
2757 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2758 jclass cls = curEnv->FindClass( className().c_str() );
2759
2760 jmethodID voidsetListBoxListBoxTopjintintjintintID = curEnv->GetStaticMethodID(cls, "setListBoxListBoxTop", "(II)V" ) ;
2761 if (voidsetListBoxListBoxTopjintintjintintID == NULL) {
2762 throw GiwsException::JniMethodNotFoundException(curEnv, "setListBoxListBoxTop");
2763 }
2764
2765                          curEnv->CallStaticVoidMethod(cls, voidsetListBoxListBoxTopjintintjintintID ,objID, index);
2766                         curEnv->DeleteLocalRef(cls);
2767 if (curEnv->ExceptionCheck()) {
2768 throw GiwsException::JniCallMethodException(curEnv);
2769 }
2770 }
2771
2772 int CallScilabBridge::getListBoxListBoxTop (JavaVM * jvm_, int objID){
2773
2774 JNIEnv * curEnv = NULL;
2775 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2776 jclass cls = curEnv->FindClass( className().c_str() );
2777
2778 jmethodID jintgetListBoxListBoxTopjintintID = curEnv->GetStaticMethodID(cls, "getListBoxListBoxTop", "(I)I" ) ;
2779 if (jintgetListBoxListBoxTopjintintID == NULL) {
2780 throw GiwsException::JniMethodNotFoundException(curEnv, "getListBoxListBoxTop");
2781 }
2782
2783                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetListBoxListBoxTopjintintID ,objID));
2784                         curEnv->DeleteLocalRef(cls);
2785 if (curEnv->ExceptionCheck()) {
2786 throw GiwsException::JniCallMethodException(curEnv);
2787 }
2788 return res;
2789
2790 }
2791
2792 char** CallScilabBridge::getPopupMenuAllItemsText (JavaVM * jvm_, int objID){
2793
2794 JNIEnv * curEnv = NULL;
2795 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2796 jclass cls = curEnv->FindClass( className().c_str() );
2797
2798 jmethodID jobjectArray_getPopupMenuAllItemsTextjintintID = curEnv->GetStaticMethodID(cls, "getPopupMenuAllItemsText", "(I)[Ljava/lang/String;" ) ;
2799 if (jobjectArray_getPopupMenuAllItemsTextjintintID == NULL) {
2800 throw GiwsException::JniMethodNotFoundException(curEnv, "getPopupMenuAllItemsText");
2801 }
2802
2803                         jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray_getPopupMenuAllItemsTextjintintID ,objID));
2804                         if (curEnv->ExceptionCheck()) {
2805 throw GiwsException::JniCallMethodException(curEnv);
2806 }int lenRow;
2807  lenRow = curEnv->GetArrayLength(res);
2808
2809 char **arrayOfString;
2810 arrayOfString = new char *[lenRow];
2811 for (jsize i = 0; i < lenRow; i++){
2812 jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
2813 const char *tempString = curEnv->GetStringUTFChars(resString, 0);
2814 arrayOfString[i] = new char[strlen(tempString) + 1];
2815
2816 strcpy(arrayOfString[i], tempString);
2817 curEnv->ReleaseStringUTFChars(resString, tempString);
2818 curEnv->DeleteLocalRef(resString);
2819 }
2820 curEnv->DeleteLocalRef(cls);
2821 if (curEnv->ExceptionCheck()) {
2822 delete[] arrayOfString;
2823                                 throw GiwsException::JniCallMethodException(curEnv);
2824 }
2825 curEnv->DeleteLocalRef(res);
2826 return arrayOfString;
2827
2828 }
2829
2830 int CallScilabBridge::getPopupMenuNumberOfItems (JavaVM * jvm_, int objID){
2831
2832 JNIEnv * curEnv = NULL;
2833 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2834 jclass cls = curEnv->FindClass( className().c_str() );
2835
2836 jmethodID jintgetPopupMenuNumberOfItemsjintintID = curEnv->GetStaticMethodID(cls, "getPopupMenuNumberOfItems", "(I)I" ) ;
2837 if (jintgetPopupMenuNumberOfItemsjintintID == NULL) {
2838 throw GiwsException::JniMethodNotFoundException(curEnv, "getPopupMenuNumberOfItems");
2839 }
2840
2841                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetPopupMenuNumberOfItemsjintintID ,objID));
2842                         curEnv->DeleteLocalRef(cls);
2843 if (curEnv->ExceptionCheck()) {
2844 throw GiwsException::JniCallMethodException(curEnv);
2845 }
2846 return res;
2847
2848 }
2849
2850 void CallScilabBridge::setPopupMenuText (JavaVM * jvm_, int objID, char const* const* text, int textSize){
2851
2852 JNIEnv * curEnv = NULL;
2853 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2854 jclass cls = curEnv->FindClass( className().c_str() );
2855
2856 jmethodID voidsetPopupMenuTextjintintjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setPopupMenuText", "(I[Ljava/lang/String;)V" ) ;
2857 if (voidsetPopupMenuTextjintintjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
2858 throw GiwsException::JniMethodNotFoundException(curEnv, "setPopupMenuText");
2859 }
2860 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
2861
2862 // create java array of strings.
2863 jobjectArray text_ = curEnv->NewObjectArray( textSize, stringArrayClass, NULL);
2864 if (text_ == NULL)
2865 {
2866 throw GiwsException::JniBadAllocException(curEnv);
2867 }
2868
2869 // convert each char * to java strings and fill the java array.
2870 for ( int i = 0; i < textSize; i++)
2871 {
2872 jstring TempString = curEnv->NewStringUTF( text[i] );
2873 if (TempString == NULL)
2874 {
2875 throw GiwsException::JniBadAllocException(curEnv);
2876 }
2877
2878 curEnv->SetObjectArrayElement( text_, i, TempString);
2879
2880 // avoid keeping reference on to many strings
2881 curEnv->DeleteLocalRef(TempString);
2882 }
2883                          curEnv->CallStaticVoidMethod(cls, voidsetPopupMenuTextjintintjobjectArray_java_lang_Stringjava_lang_StringID ,objID, text_);
2884                         curEnv->DeleteLocalRef(stringArrayClass);
2885 curEnv->DeleteLocalRef(text_);
2886 curEnv->DeleteLocalRef(cls);
2887 if (curEnv->ExceptionCheck()) {
2888 throw GiwsException::JniCallMethodException(curEnv);
2889 }
2890 }
2891
2892 void CallScilabBridge::setWidgetRelief (JavaVM * jvm_, int objID, char const* reliefType){
2893
2894 JNIEnv * curEnv = NULL;
2895 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2896 jclass cls = curEnv->FindClass( className().c_str() );
2897
2898 jmethodID voidsetWidgetReliefjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setWidgetRelief", "(ILjava/lang/String;)V" ) ;
2899 if (voidsetWidgetReliefjintintjstringjava_lang_StringID == NULL) {
2900 throw GiwsException::JniMethodNotFoundException(curEnv, "setWidgetRelief");
2901 }
2902
2903 jstring reliefType_ = curEnv->NewStringUTF( reliefType );
2904 if (reliefType != NULL && reliefType_ == NULL)
2905 {
2906 throw GiwsException::JniBadAllocException(curEnv);
2907 }
2908
2909
2910                          curEnv->CallStaticVoidMethod(cls, voidsetWidgetReliefjintintjstringjava_lang_StringID ,objID, reliefType_);
2911                         curEnv->DeleteLocalRef(reliefType_);
2912 curEnv->DeleteLocalRef(cls);
2913 if (curEnv->ExceptionCheck()) {
2914 throw GiwsException::JniCallMethodException(curEnv);
2915 }
2916 }
2917
2918 void CallScilabBridge::setFrameRelief (JavaVM * jvm_, int objID, char const* reliefType){
2919
2920 JNIEnv * curEnv = NULL;
2921 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2922 jclass cls = curEnv->FindClass( className().c_str() );
2923
2924 jmethodID voidsetFrameReliefjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setFrameRelief", "(ILjava/lang/String;)V" ) ;
2925 if (voidsetFrameReliefjintintjstringjava_lang_StringID == NULL) {
2926 throw GiwsException::JniMethodNotFoundException(curEnv, "setFrameRelief");
2927 }
2928
2929 jstring reliefType_ = curEnv->NewStringUTF( reliefType );
2930 if (reliefType != NULL && reliefType_ == NULL)
2931 {
2932 throw GiwsException::JniBadAllocException(curEnv);
2933 }
2934
2935
2936                          curEnv->CallStaticVoidMethod(cls, voidsetFrameReliefjintintjstringjava_lang_StringID ,objID, reliefType_);
2937                         curEnv->DeleteLocalRef(reliefType_);
2938 curEnv->DeleteLocalRef(cls);
2939 if (curEnv->ExceptionCheck()) {
2940 throw GiwsException::JniCallMethodException(curEnv);
2941 }
2942 }
2943
2944 void CallScilabBridge::setMenuEnabled (JavaVM * jvm_, char const* parentUID, char const* menuName, bool status){
2945
2946 JNIEnv * curEnv = NULL;
2947 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2948 jclass cls = curEnv->FindClass( className().c_str() );
2949
2950 jmethodID voidsetMenuEnabledjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "setMenuEnabled", "(Ljava/lang/String;Ljava/lang/String;Z)V" ) ;
2951 if (voidsetMenuEnabledjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID == NULL) {
2952 throw GiwsException::JniMethodNotFoundException(curEnv, "setMenuEnabled");
2953 }
2954
2955 jstring parentUID_ = curEnv->NewStringUTF( parentUID );
2956 if (parentUID != NULL && parentUID_ == NULL)
2957 {
2958 throw GiwsException::JniBadAllocException(curEnv);
2959 }
2960
2961
2962 jstring menuName_ = curEnv->NewStringUTF( menuName );
2963 if (menuName != NULL && menuName_ == NULL)
2964 {
2965 throw GiwsException::JniBadAllocException(curEnv);
2966 }
2967
2968
2969 jboolean status_ = (static_cast<bool>(status) ? JNI_TRUE : JNI_FALSE);
2970
2971                          curEnv->CallStaticVoidMethod(cls, voidsetMenuEnabledjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID ,parentUID_, menuName_, status_);
2972                         curEnv->DeleteLocalRef(parentUID_);
2973 curEnv->DeleteLocalRef(menuName_);
2974 curEnv->DeleteLocalRef(cls);
2975 if (curEnv->ExceptionCheck()) {
2976 throw GiwsException::JniCallMethodException(curEnv);
2977 }
2978 }
2979
2980 void CallScilabBridge::setSubMenuEnabled (JavaVM * jvm_, char const* parentUID, char const* menuName, int position, bool status){
2981
2982 JNIEnv * curEnv = NULL;
2983 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
2984 jclass cls = curEnv->FindClass( className().c_str() );
2985
2986 jmethodID voidsetSubMenuEnabledjstringjava_lang_Stringjstringjava_lang_StringjintintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "setSubMenuEnabled", "(Ljava/lang/String;Ljava/lang/String;IZ)V" ) ;
2987 if (voidsetSubMenuEnabledjstringjava_lang_Stringjstringjava_lang_StringjintintjbooleanbooleanID == NULL) {
2988 throw GiwsException::JniMethodNotFoundException(curEnv, "setSubMenuEnabled");
2989 }
2990
2991 jstring parentUID_ = curEnv->NewStringUTF( parentUID );
2992 if (parentUID != NULL && parentUID_ == NULL)
2993 {
2994 throw GiwsException::JniBadAllocException(curEnv);
2995 }
2996
2997
2998 jstring menuName_ = curEnv->NewStringUTF( menuName );
2999 if (menuName != NULL && menuName_ == NULL)
3000 {
3001 throw GiwsException::JniBadAllocException(curEnv);
3002 }
3003
3004
3005 jboolean status_ = (static_cast<bool>(status) ? JNI_TRUE : JNI_FALSE);
3006
3007                          curEnv->CallStaticVoidMethod(cls, voidsetSubMenuEnabledjstringjava_lang_Stringjstringjava_lang_StringjintintjbooleanbooleanID ,parentUID_, menuName_, position, status_);
3008                         curEnv->DeleteLocalRef(parentUID_);
3009 curEnv->DeleteLocalRef(menuName_);
3010 curEnv->DeleteLocalRef(cls);
3011 if (curEnv->ExceptionCheck()) {
3012 throw GiwsException::JniCallMethodException(curEnv);
3013 }
3014 }
3015
3016 void CallScilabBridge::setWidgetEnable (JavaVM * jvm_, int objID, bool status){
3017
3018 JNIEnv * curEnv = NULL;
3019 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3020 jclass cls = curEnv->FindClass( className().c_str() );
3021
3022 jmethodID voidsetWidgetEnablejintintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "setWidgetEnable", "(IZ)V" ) ;
3023 if (voidsetWidgetEnablejintintjbooleanbooleanID == NULL) {
3024 throw GiwsException::JniMethodNotFoundException(curEnv, "setWidgetEnable");
3025 }
3026
3027 jboolean status_ = (static_cast<bool>(status) ? JNI_TRUE : JNI_FALSE);
3028
3029                          curEnv->CallStaticVoidMethod(cls, voidsetWidgetEnablejintintjbooleanbooleanID ,objID, status_);
3030                         curEnv->DeleteLocalRef(cls);
3031 if (curEnv->ExceptionCheck()) {
3032 throw GiwsException::JniCallMethodException(curEnv);
3033 }
3034 }
3035
3036 void CallScilabBridge::setFrameEnable (JavaVM * jvm_, int objID, bool status){
3037
3038 JNIEnv * curEnv = NULL;
3039 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3040 jclass cls = curEnv->FindClass( className().c_str() );
3041
3042 jmethodID voidsetFrameEnablejintintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "setFrameEnable", "(IZ)V" ) ;
3043 if (voidsetFrameEnablejintintjbooleanbooleanID == NULL) {
3044 throw GiwsException::JniMethodNotFoundException(curEnv, "setFrameEnable");
3045 }
3046
3047 jboolean status_ = (static_cast<bool>(status) ? JNI_TRUE : JNI_FALSE);
3048
3049                          curEnv->CallStaticVoidMethod(cls, voidsetFrameEnablejintintjbooleanbooleanID ,objID, status_);
3050                         curEnv->DeleteLocalRef(cls);
3051 if (curEnv->ExceptionCheck()) {
3052 throw GiwsException::JniCallMethodException(curEnv);
3053 }
3054 }
3055
3056 bool CallScilabBridge::isWidgetEnable (JavaVM * jvm_, int objID){
3057
3058 JNIEnv * curEnv = NULL;
3059 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3060 jclass cls = curEnv->FindClass( className().c_str() );
3061
3062 jmethodID jbooleanisWidgetEnablejintintID = curEnv->GetStaticMethodID(cls, "isWidgetEnable", "(I)Z" ) ;
3063 if (jbooleanisWidgetEnablejintintID == NULL) {
3064 throw GiwsException::JniMethodNotFoundException(curEnv, "isWidgetEnable");
3065 }
3066
3067                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanisWidgetEnablejintintID ,objID));
3068                         curEnv->DeleteLocalRef(cls);
3069 if (curEnv->ExceptionCheck()) {
3070 throw GiwsException::JniCallMethodException(curEnv);
3071 }
3072 return (res == JNI_TRUE);
3073
3074 }
3075
3076 bool CallScilabBridge::isFrameEnable (JavaVM * jvm_, int objID){
3077
3078 JNIEnv * curEnv = NULL;
3079 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3080 jclass cls = curEnv->FindClass( className().c_str() );
3081
3082 jmethodID jbooleanisFrameEnablejintintID = curEnv->GetStaticMethodID(cls, "isFrameEnable", "(I)Z" ) ;
3083 if (jbooleanisFrameEnablejintintID == NULL) {
3084 throw GiwsException::JniMethodNotFoundException(curEnv, "isFrameEnable");
3085 }
3086
3087                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanisFrameEnablejintintID ,objID));
3088                         curEnv->DeleteLocalRef(cls);
3089 if (curEnv->ExceptionCheck()) {
3090 throw GiwsException::JniCallMethodException(curEnv);
3091 }
3092 return (res == JNI_TRUE);
3093
3094 }
3095
3096 void CallScilabBridge::setMenuChecked (JavaVM * jvm_, int objID, bool status){
3097
3098 JNIEnv * curEnv = NULL;
3099 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3100 jclass cls = curEnv->FindClass( className().c_str() );
3101
3102 jmethodID voidsetMenuCheckedjintintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "setMenuChecked", "(IZ)V" ) ;
3103 if (voidsetMenuCheckedjintintjbooleanbooleanID == NULL) {
3104 throw GiwsException::JniMethodNotFoundException(curEnv, "setMenuChecked");
3105 }
3106
3107 jboolean status_ = (static_cast<bool>(status) ? JNI_TRUE : JNI_FALSE);
3108
3109                          curEnv->CallStaticVoidMethod(cls, voidsetMenuCheckedjintintjbooleanbooleanID ,objID, status_);
3110                         curEnv->DeleteLocalRef(cls);
3111 if (curEnv->ExceptionCheck()) {
3112 throw GiwsException::JniCallMethodException(curEnv);
3113 }
3114 }
3115
3116 bool CallScilabBridge::isMenuChecked (JavaVM * jvm_, int objID){
3117
3118 JNIEnv * curEnv = NULL;
3119 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3120 jclass cls = curEnv->FindClass( className().c_str() );
3121
3122 jmethodID jbooleanisMenuCheckedjintintID = curEnv->GetStaticMethodID(cls, "isMenuChecked", "(I)Z" ) ;
3123 if (jbooleanisMenuCheckedjintintID == NULL) {
3124 throw GiwsException::JniMethodNotFoundException(curEnv, "isMenuChecked");
3125 }
3126
3127                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanisMenuCheckedjintintID ,objID));
3128                         curEnv->DeleteLocalRef(cls);
3129 if (curEnv->ExceptionCheck()) {
3130 throw GiwsException::JniCallMethodException(curEnv);
3131 }
3132 return (res == JNI_TRUE);
3133
3134 }
3135
3136 void CallScilabBridge::removeMenu (JavaVM * jvm_, char const* parentUID, char const* menuName){
3137
3138 JNIEnv * curEnv = NULL;
3139 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3140 jclass cls = curEnv->FindClass( className().c_str() );
3141
3142 jmethodID voidremoveMenujstringjava_lang_Stringjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "removeMenu", "(Ljava/lang/String;Ljava/lang/String;)V" ) ;
3143 if (voidremoveMenujstringjava_lang_Stringjstringjava_lang_StringID == NULL) {
3144 throw GiwsException::JniMethodNotFoundException(curEnv, "removeMenu");
3145 }
3146
3147 jstring parentUID_ = curEnv->NewStringUTF( parentUID );
3148 if (parentUID != NULL && parentUID_ == NULL)
3149 {
3150 throw GiwsException::JniBadAllocException(curEnv);
3151 }
3152
3153
3154 jstring menuName_ = curEnv->NewStringUTF( menuName );
3155 if (menuName != NULL && menuName_ == NULL)
3156 {
3157 throw GiwsException::JniBadAllocException(curEnv);
3158 }
3159
3160
3161                          curEnv->CallStaticVoidMethod(cls, voidremoveMenujstringjava_lang_Stringjstringjava_lang_StringID ,parentUID_, menuName_);
3162                         curEnv->DeleteLocalRef(parentUID_);
3163 curEnv->DeleteLocalRef(menuName_);
3164 curEnv->DeleteLocalRef(cls);
3165 if (curEnv->ExceptionCheck()) {
3166 throw GiwsException::JniCallMethodException(curEnv);
3167 }
3168 }
3169
3170 char* CallScilabBridge::displayAndWaitContextMenu (JavaVM * jvm_, char const* UID){
3171
3172 JNIEnv * curEnv = NULL;
3173 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3174 jclass cls = curEnv->FindClass( className().c_str() );
3175
3176 jmethodID jstringdisplayAndWaitContextMenujstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "displayAndWaitContextMenu", "(Ljava/lang/String;)Ljava/lang/String;" ) ;
3177 if (jstringdisplayAndWaitContextMenujstringjava_lang_StringID == NULL) {
3178 throw GiwsException::JniMethodNotFoundException(curEnv, "displayAndWaitContextMenu");
3179 }
3180
3181 jstring UID_ = curEnv->NewStringUTF( UID );
3182 if (UID != NULL && UID_ == NULL)
3183 {
3184 throw GiwsException::JniBadAllocException(curEnv);
3185 }
3186
3187
3188                         jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringdisplayAndWaitContextMenujstringjava_lang_StringID ,UID_));
3189                         if (curEnv->ExceptionCheck()) {
3190 throw GiwsException::JniCallMethodException(curEnv);
3191 }
3192
3193 const char *tempString = curEnv->GetStringUTFChars(res, 0);
3194 char * myStringBuffer = new char[strlen(tempString) + 1];
3195 strcpy(myStringBuffer, tempString);
3196 curEnv->ReleaseStringUTFChars(res, tempString);
3197 curEnv->DeleteLocalRef(res);
3198 curEnv->DeleteLocalRef(UID_);
3199 curEnv->DeleteLocalRef(cls);
3200 if (curEnv->ExceptionCheck()) {
3201 delete[] myStringBuffer;
3202                                 throw GiwsException::JniCallMethodException(curEnv);
3203 }
3204 return myStringBuffer;
3205
3206 }
3207
3208 int CallScilabBridge::newMessageBox (JavaVM * jvm_){
3209
3210 JNIEnv * curEnv = NULL;
3211 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3212 jclass cls = curEnv->FindClass( className().c_str() );
3213
3214 jmethodID jintnewMessageBoxID = curEnv->GetStaticMethodID(cls, "newMessageBox", "()I" ) ;
3215 if (jintnewMessageBoxID == NULL) {
3216 throw GiwsException::JniMethodNotFoundException(curEnv, "newMessageBox");
3217 }
3218
3219                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewMessageBoxID ));
3220                         curEnv->DeleteLocalRef(cls);
3221 if (curEnv->ExceptionCheck()) {
3222 throw GiwsException::JniCallMethodException(curEnv);
3223 }
3224 return res;
3225
3226 }
3227
3228 void CallScilabBridge::setMessageBoxTitle (JavaVM * jvm_, int id, char const* title){
3229
3230 JNIEnv * curEnv = NULL;
3231 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3232 jclass cls = curEnv->FindClass( className().c_str() );
3233
3234 jmethodID voidsetMessageBoxTitlejintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setMessageBoxTitle", "(ILjava/lang/String;)V" ) ;
3235 if (voidsetMessageBoxTitlejintintjstringjava_lang_StringID == NULL) {
3236 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxTitle");
3237 }
3238
3239 jstring title_ = curEnv->NewStringUTF( title );
3240 if (title != NULL && title_ == NULL)
3241 {
3242 throw GiwsException::JniBadAllocException(curEnv);
3243 }
3244
3245
3246                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxTitlejintintjstringjava_lang_StringID ,id, title_);
3247                         curEnv->DeleteLocalRef(title_);
3248 curEnv->DeleteLocalRef(cls);
3249 if (curEnv->ExceptionCheck()) {
3250 throw GiwsException::JniCallMethodException(curEnv);
3251 }
3252 }
3253
3254 void CallScilabBridge::setMessageBoxMessage (JavaVM * jvm_, int id, char const* message){
3255
3256 JNIEnv * curEnv = NULL;
3257 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3258 jclass cls = curEnv->FindClass( className().c_str() );
3259
3260 jmethodID voidsetMessageBoxMessagejintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setMessageBoxMessage", "(ILjava/lang/String;)V" ) ;
3261 if (voidsetMessageBoxMessagejintintjstringjava_lang_StringID == NULL) {
3262 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxMessage");
3263 }
3264
3265 jstring message_ = curEnv->NewStringUTF( message );
3266 if (message != NULL && message_ == NULL)
3267 {
3268 throw GiwsException::JniBadAllocException(curEnv);
3269 }
3270
3271
3272                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxMessagejintintjstringjava_lang_StringID ,id, message_);
3273                         curEnv->DeleteLocalRef(message_);
3274 curEnv->DeleteLocalRef(cls);
3275 if (curEnv->ExceptionCheck()) {
3276 throw GiwsException::JniCallMethodException(curEnv);
3277 }
3278 }
3279
3280 void CallScilabBridge::setMessageBoxMessage (JavaVM * jvm_, int id, char const* const* message, int messageSize){
3281
3282 JNIEnv * curEnv = NULL;
3283 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3284 jclass cls = curEnv->FindClass( className().c_str() );
3285
3286 jmethodID voidsetMessageBoxMessagejintintjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setMessageBoxMessage", "(I[Ljava/lang/String;)V" ) ;
3287 if (voidsetMessageBoxMessagejintintjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
3288 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxMessage");
3289 }
3290 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
3291
3292 // create java array of strings.
3293 jobjectArray message_ = curEnv->NewObjectArray( messageSize, stringArrayClass, NULL);
3294 if (message_ == NULL)
3295 {
3296 throw GiwsException::JniBadAllocException(curEnv);
3297 }
3298
3299 // convert each char * to java strings and fill the java array.
3300 for ( int i = 0; i < messageSize; i++)
3301 {
3302 jstring TempString = curEnv->NewStringUTF( message[i] );
3303 if (TempString == NULL)
3304 {
3305 throw GiwsException::JniBadAllocException(curEnv);
3306 }
3307
3308 curEnv->SetObjectArrayElement( message_, i, TempString);
3309
3310 // avoid keeping reference on to many strings
3311 curEnv->DeleteLocalRef(TempString);
3312 }
3313                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxMessagejintintjobjectArray_java_lang_Stringjava_lang_StringID ,id, message_);
3314                         curEnv->DeleteLocalRef(stringArrayClass);
3315 curEnv->DeleteLocalRef(message_);
3316 curEnv->DeleteLocalRef(cls);
3317 if (curEnv->ExceptionCheck()) {
3318 throw GiwsException::JniCallMethodException(curEnv);
3319 }
3320 }
3321
3322 void CallScilabBridge::messageBoxDisplayAndWait (JavaVM * jvm_, int id){
3323
3324 JNIEnv * curEnv = NULL;
3325 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3326 jclass cls = curEnv->FindClass( className().c_str() );
3327
3328 jmethodID voidmessageBoxDisplayAndWaitjintintID = curEnv->GetStaticMethodID(cls, "messageBoxDisplayAndWait", "(I)V" ) ;
3329 if (voidmessageBoxDisplayAndWaitjintintID == NULL) {
3330 throw GiwsException::JniMethodNotFoundException(curEnv, "messageBoxDisplayAndWait");
3331 }
3332
3333                          curEnv->CallStaticVoidMethod(cls, voidmessageBoxDisplayAndWaitjintintID ,id);
3334                         curEnv->DeleteLocalRef(cls);
3335 if (curEnv->ExceptionCheck()) {
3336 throw GiwsException::JniCallMethodException(curEnv);
3337 }
3338 }
3339
3340 int CallScilabBridge::getMessageBoxSelectedButton (JavaVM * jvm_, int id){
3341
3342 JNIEnv * curEnv = NULL;
3343 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3344 jclass cls = curEnv->FindClass( className().c_str() );
3345
3346 jmethodID jintgetMessageBoxSelectedButtonjintintID = curEnv->GetStaticMethodID(cls, "getMessageBoxSelectedButton", "(I)I" ) ;
3347 if (jintgetMessageBoxSelectedButtonjintintID == NULL) {
3348 throw GiwsException::JniMethodNotFoundException(curEnv, "getMessageBoxSelectedButton");
3349 }
3350
3351                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetMessageBoxSelectedButtonjintintID ,id));
3352                         curEnv->DeleteLocalRef(cls);
3353 if (curEnv->ExceptionCheck()) {
3354 throw GiwsException::JniCallMethodException(curEnv);
3355 }
3356 return res;
3357
3358 }
3359
3360 void CallScilabBridge::setMessageBoxDefaultSelectedButtons (JavaVM * jvm_, int id, int const* index, int indexSize){
3361
3362 JNIEnv * curEnv = NULL;
3363 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3364 jclass cls = curEnv->FindClass( className().c_str() );
3365
3366 jmethodID voidsetMessageBoxDefaultSelectedButtonsjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "setMessageBoxDefaultSelectedButtons", "(I[I)V" ) ;
3367 if (voidsetMessageBoxDefaultSelectedButtonsjintintjintArray_intintID == NULL) {
3368 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxDefaultSelectedButtons");
3369 }
3370
3371 jintArray index_ = curEnv->NewIntArray( indexSize ) ;
3372
3373 if (index_ == NULL)
3374 {
3375 // check that allocation succeed
3376 throw GiwsException::JniBadAllocException(curEnv);
3377 }
3378
3379 curEnv->SetIntArrayRegion( index_, 0, indexSize, (jint*)(index) ) ;
3380
3381
3382                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxDefaultSelectedButtonsjintintjintArray_intintID ,id, index_);
3383                         curEnv->DeleteLocalRef(index_);
3384 curEnv->DeleteLocalRef(cls);
3385 if (curEnv->ExceptionCheck()) {
3386 throw GiwsException::JniCallMethodException(curEnv);
3387 }
3388 }
3389
3390 int* CallScilabBridge::getMessageBoxUserSelectedButtons (JavaVM * jvm_, int id){
3391
3392 JNIEnv * curEnv = NULL;
3393 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3394 jclass cls = curEnv->FindClass( className().c_str() );
3395
3396 jmethodID jintArray_getMessageBoxUserSelectedButtonsjintintID = curEnv->GetStaticMethodID(cls, "getMessageBoxUserSelectedButtons", "(I)[I" ) ;
3397 if (jintArray_getMessageBoxUserSelectedButtonsjintintID == NULL) {
3398 throw GiwsException::JniMethodNotFoundException(curEnv, "getMessageBoxUserSelectedButtons");
3399 }
3400
3401                         jintArray res =  static_cast<jintArray>( curEnv->CallStaticObjectMethod(cls, jintArray_getMessageBoxUserSelectedButtonsjintintID ,id));
3402                         if (res == NULL) { return NULL; }
3403                         if (curEnv->ExceptionCheck()) {
3404 throw GiwsException::JniCallMethodException(curEnv);
3405 }int lenRow;
3406  lenRow = curEnv->GetArrayLength(res);
3407 jboolean isCopy = JNI_FALSE;
3408
3409 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
3410 jint *resultsArray = static_cast<jint *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
3411 int* myArray= new int[ lenRow];
3412
3413 for (jsize i = 0; i <  lenRow; i++){
3414 myArray[i]=resultsArray[i];
3415 }
3416 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
3417
3418                         curEnv->DeleteLocalRef(res);
3419 curEnv->DeleteLocalRef(cls);
3420 if (curEnv->ExceptionCheck()) {
3421 delete[] myArray;
3422                                 throw GiwsException::JniCallMethodException(curEnv);
3423 }
3424 return myArray;
3425
3426 }
3427
3428 void CallScilabBridge::setMessageBoxButtonsLabels (JavaVM * jvm_, int id, char const* const* labels, int labelsSize){
3429
3430 JNIEnv * curEnv = NULL;
3431 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3432 jclass cls = curEnv->FindClass( className().c_str() );
3433
3434 jmethodID voidsetMessageBoxButtonsLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setMessageBoxButtonsLabels", "(I[Ljava/lang/String;)V" ) ;
3435 if (voidsetMessageBoxButtonsLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
3436 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxButtonsLabels");
3437 }
3438 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
3439
3440 // create java array of strings.
3441 jobjectArray labels_ = curEnv->NewObjectArray( labelsSize, stringArrayClass, NULL);
3442 if (labels_ == NULL)
3443 {
3444 throw GiwsException::JniBadAllocException(curEnv);
3445 }
3446
3447 // convert each char * to java strings and fill the java array.
3448 for ( int i = 0; i < labelsSize; i++)
3449 {
3450 jstring TempString = curEnv->NewStringUTF( labels[i] );
3451 if (TempString == NULL)
3452 {
3453 throw GiwsException::JniBadAllocException(curEnv);
3454 }
3455
3456 curEnv->SetObjectArrayElement( labels_, i, TempString);
3457
3458 // avoid keeping reference on to many strings
3459 curEnv->DeleteLocalRef(TempString);
3460 }
3461                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxButtonsLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID ,id, labels_);
3462                         curEnv->DeleteLocalRef(stringArrayClass);
3463 curEnv->DeleteLocalRef(labels_);
3464 curEnv->DeleteLocalRef(cls);
3465 if (curEnv->ExceptionCheck()) {
3466 throw GiwsException::JniCallMethodException(curEnv);
3467 }
3468 }
3469
3470 void CallScilabBridge::setMessageBoxInitialValue (JavaVM * jvm_, int id, char const* const* value, int valueSize){
3471
3472 JNIEnv * curEnv = NULL;
3473 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3474 jclass cls = curEnv->FindClass( className().c_str() );
3475
3476 jmethodID voidsetMessageBoxInitialValuejintintjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setMessageBoxInitialValue", "(I[Ljava/lang/String;)V" ) ;
3477 if (voidsetMessageBoxInitialValuejintintjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
3478 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxInitialValue");
3479 }
3480 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
3481
3482 // create java array of strings.
3483 jobjectArray value_ = curEnv->NewObjectArray( valueSize, stringArrayClass, NULL);
3484 if (value_ == NULL)
3485 {
3486 throw GiwsException::JniBadAllocException(curEnv);
3487 }
3488
3489 // convert each char * to java strings and fill the java array.
3490 for ( int i = 0; i < valueSize; i++)
3491 {
3492 jstring TempString = curEnv->NewStringUTF( value[i] );
3493 if (TempString == NULL)
3494 {
3495 throw GiwsException::JniBadAllocException(curEnv);
3496 }
3497
3498 curEnv->SetObjectArrayElement( value_, i, TempString);
3499
3500 // avoid keeping reference on to many strings
3501 curEnv->DeleteLocalRef(TempString);
3502 }
3503                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxInitialValuejintintjobjectArray_java_lang_Stringjava_lang_StringID ,id, value_);
3504                         curEnv->DeleteLocalRef(stringArrayClass);
3505 curEnv->DeleteLocalRef(value_);
3506 curEnv->DeleteLocalRef(cls);
3507 if (curEnv->ExceptionCheck()) {
3508 throw GiwsException::JniCallMethodException(curEnv);
3509 }
3510 }
3511
3512 char** CallScilabBridge::getMessageBoxValue (JavaVM * jvm_, int id){
3513
3514 JNIEnv * curEnv = NULL;
3515 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3516 jclass cls = curEnv->FindClass( className().c_str() );
3517
3518 jmethodID jobjectArray_getMessageBoxValuejintintID = curEnv->GetStaticMethodID(cls, "getMessageBoxValue", "(I)[Ljava/lang/String;" ) ;
3519 if (jobjectArray_getMessageBoxValuejintintID == NULL) {
3520 throw GiwsException::JniMethodNotFoundException(curEnv, "getMessageBoxValue");
3521 }
3522
3523                         jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray_getMessageBoxValuejintintID ,id));
3524                         if (curEnv->ExceptionCheck()) {
3525 throw GiwsException::JniCallMethodException(curEnv);
3526 }int lenRow;
3527  lenRow = curEnv->GetArrayLength(res);
3528
3529 char **arrayOfString;
3530 arrayOfString = new char *[lenRow];
3531 for (jsize i = 0; i < lenRow; i++){
3532 jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
3533 const char *tempString = curEnv->GetStringUTFChars(resString, 0);
3534 arrayOfString[i] = new char[strlen(tempString) + 1];
3535
3536 strcpy(arrayOfString[i], tempString);
3537 curEnv->ReleaseStringUTFChars(resString, tempString);
3538 curEnv->DeleteLocalRef(resString);
3539 }
3540 curEnv->DeleteLocalRef(cls);
3541 if (curEnv->ExceptionCheck()) {
3542 delete[] arrayOfString;
3543                                 throw GiwsException::JniCallMethodException(curEnv);
3544 }
3545 curEnv->DeleteLocalRef(res);
3546 return arrayOfString;
3547
3548 }
3549
3550 int CallScilabBridge::getMessageBoxValueSize (JavaVM * jvm_, int id){
3551
3552 JNIEnv * curEnv = NULL;
3553 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3554 jclass cls = curEnv->FindClass( className().c_str() );
3555
3556 jmethodID jintgetMessageBoxValueSizejintintID = curEnv->GetStaticMethodID(cls, "getMessageBoxValueSize", "(I)I" ) ;
3557 if (jintgetMessageBoxValueSizejintintID == NULL) {
3558 throw GiwsException::JniMethodNotFoundException(curEnv, "getMessageBoxValueSize");
3559 }
3560
3561                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetMessageBoxValueSizejintintID ,id));
3562                         curEnv->DeleteLocalRef(cls);
3563 if (curEnv->ExceptionCheck()) {
3564 throw GiwsException::JniCallMethodException(curEnv);
3565 }
3566 return res;
3567
3568 }
3569
3570 void CallScilabBridge::setMessageBoxListBoxItems (JavaVM * jvm_, int id, char const* const* items, int itemsSize){
3571
3572 JNIEnv * curEnv = NULL;
3573 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3574 jclass cls = curEnv->FindClass( className().c_str() );
3575
3576 jmethodID voidsetMessageBoxListBoxItemsjintintjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setMessageBoxListBoxItems", "(I[Ljava/lang/String;)V" ) ;
3577 if (voidsetMessageBoxListBoxItemsjintintjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
3578 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxListBoxItems");
3579 }
3580 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
3581
3582 // create java array of strings.
3583 jobjectArray items_ = curEnv->NewObjectArray( itemsSize, stringArrayClass, NULL);
3584 if (items_ == NULL)
3585 {
3586 throw GiwsException::JniBadAllocException(curEnv);
3587 }
3588
3589 // convert each char * to java strings and fill the java array.
3590 for ( int i = 0; i < itemsSize; i++)
3591 {
3592 jstring TempString = curEnv->NewStringUTF( items[i] );
3593 if (TempString == NULL)
3594 {
3595 throw GiwsException::JniBadAllocException(curEnv);
3596 }
3597
3598 curEnv->SetObjectArrayElement( items_, i, TempString);
3599
3600 // avoid keeping reference on to many strings
3601 curEnv->DeleteLocalRef(TempString);
3602 }
3603                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxListBoxItemsjintintjobjectArray_java_lang_Stringjava_lang_StringID ,id, items_);
3604                         curEnv->DeleteLocalRef(stringArrayClass);
3605 curEnv->DeleteLocalRef(items_);
3606 curEnv->DeleteLocalRef(cls);
3607 if (curEnv->ExceptionCheck()) {
3608 throw GiwsException::JniCallMethodException(curEnv);
3609 }
3610 }
3611
3612 int CallScilabBridge::getMessageBoxSelectedItem (JavaVM * jvm_, int id){
3613
3614 JNIEnv * curEnv = NULL;
3615 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3616 jclass cls = curEnv->FindClass( className().c_str() );
3617
3618 jmethodID jintgetMessageBoxSelectedItemjintintID = curEnv->GetStaticMethodID(cls, "getMessageBoxSelectedItem", "(I)I" ) ;
3619 if (jintgetMessageBoxSelectedItemjintintID == NULL) {
3620 throw GiwsException::JniMethodNotFoundException(curEnv, "getMessageBoxSelectedItem");
3621 }
3622
3623                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetMessageBoxSelectedItemjintintID ,id));
3624                         curEnv->DeleteLocalRef(cls);
3625 if (curEnv->ExceptionCheck()) {
3626 throw GiwsException::JniCallMethodException(curEnv);
3627 }
3628 return res;
3629
3630 }
3631
3632 void CallScilabBridge::setMessageBoxLineLabels (JavaVM * jvm_, int id, char const* const* labels, int labelsSize){
3633
3634 JNIEnv * curEnv = NULL;
3635 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3636 jclass cls = curEnv->FindClass( className().c_str() );
3637
3638 jmethodID voidsetMessageBoxLineLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setMessageBoxLineLabels", "(I[Ljava/lang/String;)V" ) ;
3639 if (voidsetMessageBoxLineLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
3640 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxLineLabels");
3641 }
3642 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
3643
3644 // create java array of strings.
3645 jobjectArray labels_ = curEnv->NewObjectArray( labelsSize, stringArrayClass, NULL);
3646 if (labels_ == NULL)
3647 {
3648 throw GiwsException::JniBadAllocException(curEnv);
3649 }
3650
3651 // convert each char * to java strings and fill the java array.
3652 for ( int i = 0; i < labelsSize; i++)
3653 {
3654 jstring TempString = curEnv->NewStringUTF( labels[i] );
3655 if (TempString == NULL)
3656 {
3657 throw GiwsException::JniBadAllocException(curEnv);
3658 }
3659
3660 curEnv->SetObjectArrayElement( labels_, i, TempString);
3661
3662 // avoid keeping reference on to many strings
3663 curEnv->DeleteLocalRef(TempString);
3664 }
3665                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxLineLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID ,id, labels_);
3666                         curEnv->DeleteLocalRef(stringArrayClass);
3667 curEnv->DeleteLocalRef(labels_);
3668 curEnv->DeleteLocalRef(cls);
3669 if (curEnv->ExceptionCheck()) {
3670 throw GiwsException::JniCallMethodException(curEnv);
3671 }
3672 }
3673
3674 void CallScilabBridge::setMessageBoxColumnLabels (JavaVM * jvm_, int id, char const* const* labels, int labelsSize){
3675
3676 JNIEnv * curEnv = NULL;
3677 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3678 jclass cls = curEnv->FindClass( className().c_str() );
3679
3680 jmethodID voidsetMessageBoxColumnLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setMessageBoxColumnLabels", "(I[Ljava/lang/String;)V" ) ;
3681 if (voidsetMessageBoxColumnLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
3682 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxColumnLabels");
3683 }
3684 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
3685
3686 // create java array of strings.
3687 jobjectArray labels_ = curEnv->NewObjectArray( labelsSize, stringArrayClass, NULL);
3688 if (labels_ == NULL)
3689 {
3690 throw GiwsException::JniBadAllocException(curEnv);
3691 }
3692
3693 // convert each char * to java strings and fill the java array.
3694 for ( int i = 0; i < labelsSize; i++)
3695 {
3696 jstring TempString = curEnv->NewStringUTF( labels[i] );
3697 if (TempString == NULL)
3698 {
3699 throw GiwsException::JniBadAllocException(curEnv);
3700 }
3701
3702 curEnv->SetObjectArrayElement( labels_, i, TempString);
3703
3704 // avoid keeping reference on to many strings
3705 curEnv->DeleteLocalRef(TempString);
3706 }
3707                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxColumnLabelsjintintjobjectArray_java_lang_Stringjava_lang_StringID ,id, labels_);
3708                         curEnv->DeleteLocalRef(stringArrayClass);
3709 curEnv->DeleteLocalRef(labels_);
3710 curEnv->DeleteLocalRef(cls);
3711 if (curEnv->ExceptionCheck()) {
3712 throw GiwsException::JniCallMethodException(curEnv);
3713 }
3714 }
3715
3716 void CallScilabBridge::setMessageBoxDefaultInput (JavaVM * jvm_, int id, char const* const* values, int valuesSize){
3717
3718 JNIEnv * curEnv = NULL;
3719 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3720 jclass cls = curEnv->FindClass( className().c_str() );
3721
3722 jmethodID voidsetMessageBoxDefaultInputjintintjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setMessageBoxDefaultInput", "(I[Ljava/lang/String;)V" ) ;
3723 if (voidsetMessageBoxDefaultInputjintintjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
3724 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxDefaultInput");
3725 }
3726 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
3727
3728 // create java array of strings.
3729 jobjectArray values_ = curEnv->NewObjectArray( valuesSize, stringArrayClass, NULL);
3730 if (values_ == NULL)
3731 {
3732 throw GiwsException::JniBadAllocException(curEnv);
3733 }
3734
3735 // convert each char * to java strings and fill the java array.
3736 for ( int i = 0; i < valuesSize; i++)
3737 {
3738 jstring TempString = curEnv->NewStringUTF( values[i] );
3739 if (TempString == NULL)
3740 {
3741 throw GiwsException::JniBadAllocException(curEnv);
3742 }
3743
3744 curEnv->SetObjectArrayElement( values_, i, TempString);
3745
3746 // avoid keeping reference on to many strings
3747 curEnv->DeleteLocalRef(TempString);
3748 }
3749                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxDefaultInputjintintjobjectArray_java_lang_Stringjava_lang_StringID ,id, values_);
3750                         curEnv->DeleteLocalRef(stringArrayClass);
3751 curEnv->DeleteLocalRef(values_);
3752 curEnv->DeleteLocalRef(cls);
3753 if (curEnv->ExceptionCheck()) {
3754 throw GiwsException::JniCallMethodException(curEnv);
3755 }
3756 }
3757
3758 void CallScilabBridge::setMessageBoxModal (JavaVM * jvm_, int id, bool status){
3759
3760 JNIEnv * curEnv = NULL;
3761 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3762 jclass cls = curEnv->FindClass( className().c_str() );
3763
3764 jmethodID voidsetMessageBoxModaljintintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "setMessageBoxModal", "(IZ)V" ) ;
3765 if (voidsetMessageBoxModaljintintjbooleanbooleanID == NULL) {
3766 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxModal");
3767 }
3768
3769 jboolean status_ = (static_cast<bool>(status) ? JNI_TRUE : JNI_FALSE);
3770
3771                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxModaljintintjbooleanbooleanID ,id, status_);
3772                         curEnv->DeleteLocalRef(cls);
3773 if (curEnv->ExceptionCheck()) {
3774 throw GiwsException::JniCallMethodException(curEnv);
3775 }
3776 }
3777
3778 void CallScilabBridge::setMessageBoxIcon (JavaVM * jvm_, int id, char const* name){
3779
3780 JNIEnv * curEnv = NULL;
3781 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3782 jclass cls = curEnv->FindClass( className().c_str() );
3783
3784 jmethodID voidsetMessageBoxIconjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setMessageBoxIcon", "(ILjava/lang/String;)V" ) ;
3785 if (voidsetMessageBoxIconjintintjstringjava_lang_StringID == NULL) {
3786 throw GiwsException::JniMethodNotFoundException(curEnv, "setMessageBoxIcon");
3787 }
3788
3789 jstring name_ = curEnv->NewStringUTF( name );
3790 if (name != NULL && name_ == NULL)
3791 {
3792 throw GiwsException::JniBadAllocException(curEnv);
3793 }
3794
3795
3796                          curEnv->CallStaticVoidMethod(cls, voidsetMessageBoxIconjintintjstringjava_lang_StringID ,id, name_);
3797                         curEnv->DeleteLocalRef(name_);
3798 curEnv->DeleteLocalRef(cls);
3799 if (curEnv->ExceptionCheck()) {
3800 throw GiwsException::JniCallMethodException(curEnv);
3801 }
3802 }
3803
3804 bool CallScilabBridge::isToolbarVisible (JavaVM * jvm_, char const* parentUID){
3805
3806 JNIEnv * curEnv = NULL;
3807 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3808 jclass cls = curEnv->FindClass( className().c_str() );
3809
3810 jmethodID jbooleanisToolbarVisiblejstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "isToolbarVisible", "(Ljava/lang/String;)Z" ) ;
3811 if (jbooleanisToolbarVisiblejstringjava_lang_StringID == NULL) {
3812 throw GiwsException::JniMethodNotFoundException(curEnv, "isToolbarVisible");
3813 }
3814
3815 jstring parentUID_ = curEnv->NewStringUTF( parentUID );
3816 if (parentUID != NULL && parentUID_ == NULL)
3817 {
3818 throw GiwsException::JniBadAllocException(curEnv);
3819 }
3820
3821
3822                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanisToolbarVisiblejstringjava_lang_StringID ,parentUID_));
3823                         curEnv->DeleteLocalRef(parentUID_);
3824 curEnv->DeleteLocalRef(cls);
3825 if (curEnv->ExceptionCheck()) {
3826 throw GiwsException::JniCallMethodException(curEnv);
3827 }
3828 return (res == JNI_TRUE);
3829
3830 }
3831
3832 void CallScilabBridge::setToolbarVisible (JavaVM * jvm_, char const* parentUID, bool status){
3833
3834 JNIEnv * curEnv = NULL;
3835 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3836 jclass cls = curEnv->FindClass( className().c_str() );
3837
3838 jmethodID voidsetToolbarVisiblejstringjava_lang_StringjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "setToolbarVisible", "(Ljava/lang/String;Z)V" ) ;
3839 if (voidsetToolbarVisiblejstringjava_lang_StringjbooleanbooleanID == NULL) {
3840 throw GiwsException::JniMethodNotFoundException(curEnv, "setToolbarVisible");
3841 }
3842
3843 jstring parentUID_ = curEnv->NewStringUTF( parentUID );
3844 if (parentUID != NULL && parentUID_ == NULL)
3845 {
3846 throw GiwsException::JniBadAllocException(curEnv);
3847 }
3848
3849
3850 jboolean status_ = (static_cast<bool>(status) ? JNI_TRUE : JNI_FALSE);
3851
3852                          curEnv->CallStaticVoidMethod(cls, voidsetToolbarVisiblejstringjava_lang_StringjbooleanbooleanID ,parentUID_, status_);
3853                         curEnv->DeleteLocalRef(parentUID_);
3854 curEnv->DeleteLocalRef(cls);
3855 if (curEnv->ExceptionCheck()) {
3856 throw GiwsException::JniCallMethodException(curEnv);
3857 }
3858 }
3859
3860 void CallScilabBridge::setEventHandler (JavaVM * jvm_, int figNum, char const* command){
3861
3862 JNIEnv * curEnv = NULL;
3863 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3864 jclass cls = curEnv->FindClass( className().c_str() );
3865
3866 jmethodID voidsetEventHandlerjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setEventHandler", "(ILjava/lang/String;)V" ) ;
3867 if (voidsetEventHandlerjintintjstringjava_lang_StringID == NULL) {
3868 throw GiwsException::JniMethodNotFoundException(curEnv, "setEventHandler");
3869 }
3870
3871 jstring command_ = curEnv->NewStringUTF( command );
3872 if (command != NULL && command_ == NULL)
3873 {
3874 throw GiwsException::JniBadAllocException(curEnv);
3875 }
3876
3877
3878                          curEnv->CallStaticVoidMethod(cls, voidsetEventHandlerjintintjstringjava_lang_StringID ,figNum, command_);
3879                         curEnv->DeleteLocalRef(command_);
3880 curEnv->DeleteLocalRef(cls);
3881 if (curEnv->ExceptionCheck()) {
3882 throw GiwsException::JniCallMethodException(curEnv);
3883 }
3884 }
3885
3886 void CallScilabBridge::setEventHandlerEnabled (JavaVM * jvm_, int figNum, bool status){
3887
3888 JNIEnv * curEnv = NULL;
3889 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3890 jclass cls = curEnv->FindClass( className().c_str() );
3891
3892 jmethodID voidsetEventHandlerEnabledjintintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "setEventHandlerEnabled", "(IZ)V" ) ;
3893 if (voidsetEventHandlerEnabledjintintjbooleanbooleanID == NULL) {
3894 throw GiwsException::JniMethodNotFoundException(curEnv, "setEventHandlerEnabled");
3895 }
3896
3897 jboolean status_ = (static_cast<bool>(status) ? JNI_TRUE : JNI_FALSE);
3898
3899                          curEnv->CallStaticVoidMethod(cls, voidsetEventHandlerEnabledjintintjbooleanbooleanID ,figNum, status_);
3900                         curEnv->DeleteLocalRef(cls);
3901 if (curEnv->ExceptionCheck()) {
3902 throw GiwsException::JniCallMethodException(curEnv);
3903 }
3904 }
3905
3906 int CallScilabBridge::newWaitBar (JavaVM * jvm_){
3907
3908 JNIEnv * curEnv = NULL;
3909 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3910 jclass cls = curEnv->FindClass( className().c_str() );
3911
3912 jmethodID jintnewWaitBarID = curEnv->GetStaticMethodID(cls, "newWaitBar", "()I" ) ;
3913 if (jintnewWaitBarID == NULL) {
3914 throw GiwsException::JniMethodNotFoundException(curEnv, "newWaitBar");
3915 }
3916
3917                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewWaitBarID ));
3918                         curEnv->DeleteLocalRef(cls);
3919 if (curEnv->ExceptionCheck()) {
3920 throw GiwsException::JniCallMethodException(curEnv);
3921 }
3922 return res;
3923
3924 }
3925
3926 void CallScilabBridge::setWaitBarMessage (JavaVM * jvm_, int id, char const* const* message, int messageSize){
3927
3928 JNIEnv * curEnv = NULL;
3929 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3930 jclass cls = curEnv->FindClass( className().c_str() );
3931
3932 jmethodID voidsetWaitBarMessagejintintjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setWaitBarMessage", "(I[Ljava/lang/String;)V" ) ;
3933 if (voidsetWaitBarMessagejintintjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
3934 throw GiwsException::JniMethodNotFoundException(curEnv, "setWaitBarMessage");
3935 }
3936 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
3937
3938 // create java array of strings.
3939 jobjectArray message_ = curEnv->NewObjectArray( messageSize, stringArrayClass, NULL);
3940 if (message_ == NULL)
3941 {
3942 throw GiwsException::JniBadAllocException(curEnv);
3943 }
3944
3945 // convert each char * to java strings and fill the java array.
3946 for ( int i = 0; i < messageSize; i++)
3947 {
3948 jstring TempString = curEnv->NewStringUTF( message[i] );
3949 if (TempString == NULL)
3950 {
3951 throw GiwsException::JniBadAllocException(curEnv);
3952 }
3953
3954 curEnv->SetObjectArrayElement( message_, i, TempString);
3955
3956 // avoid keeping reference on to many strings
3957 curEnv->DeleteLocalRef(TempString);
3958 }
3959                          curEnv->CallStaticVoidMethod(cls, voidsetWaitBarMessagejintintjobjectArray_java_lang_Stringjava_lang_StringID ,id, message_);
3960                         curEnv->DeleteLocalRef(stringArrayClass);
3961 curEnv->DeleteLocalRef(message_);
3962 curEnv->DeleteLocalRef(cls);
3963 if (curEnv->ExceptionCheck()) {
3964 throw GiwsException::JniCallMethodException(curEnv);
3965 }
3966 }
3967
3968 void CallScilabBridge::setWaitBarValue (JavaVM * jvm_, int id, int value){
3969
3970 JNIEnv * curEnv = NULL;
3971 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3972 jclass cls = curEnv->FindClass( className().c_str() );
3973
3974 jmethodID voidsetWaitBarValuejintintjintintID = curEnv->GetStaticMethodID(cls, "setWaitBarValue", "(II)V" ) ;
3975 if (voidsetWaitBarValuejintintjintintID == NULL) {
3976 throw GiwsException::JniMethodNotFoundException(curEnv, "setWaitBarValue");
3977 }
3978
3979                          curEnv->CallStaticVoidMethod(cls, voidsetWaitBarValuejintintjintintID ,id, value);
3980                         curEnv->DeleteLocalRef(cls);
3981 if (curEnv->ExceptionCheck()) {
3982 throw GiwsException::JniCallMethodException(curEnv);
3983 }
3984 }
3985
3986 void CallScilabBridge::destroyWaitBar (JavaVM * jvm_, int objID){
3987
3988 JNIEnv * curEnv = NULL;
3989 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
3990 jclass cls = curEnv->FindClass( className().c_str() );
3991
3992 jmethodID voiddestroyWaitBarjintintID = curEnv->GetStaticMethodID(cls, "destroyWaitBar", "(I)V" ) ;
3993 if (voiddestroyWaitBarjintintID == NULL) {
3994 throw GiwsException::JniMethodNotFoundException(curEnv, "destroyWaitBar");
3995 }
3996
3997                          curEnv->CallStaticVoidMethod(cls, voiddestroyWaitBarjintintID ,objID);
3998                         curEnv->DeleteLocalRef(cls);
3999 if (curEnv->ExceptionCheck()) {
4000 throw GiwsException::JniCallMethodException(curEnv);
4001 }
4002 }
4003
4004 void CallScilabBridge::setWaitBarIndeterminateMode (JavaVM * jvm_, int objID, bool status){
4005
4006 JNIEnv * curEnv = NULL;
4007 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4008 jclass cls = curEnv->FindClass( className().c_str() );
4009
4010 jmethodID voidsetWaitBarIndeterminateModejintintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "setWaitBarIndeterminateMode", "(IZ)V" ) ;
4011 if (voidsetWaitBarIndeterminateModejintintjbooleanbooleanID == NULL) {
4012 throw GiwsException::JniMethodNotFoundException(curEnv, "setWaitBarIndeterminateMode");
4013 }
4014
4015 jboolean status_ = (static_cast<bool>(status) ? JNI_TRUE : JNI_FALSE);
4016
4017                          curEnv->CallStaticVoidMethod(cls, voidsetWaitBarIndeterminateModejintintjbooleanbooleanID ,objID, status_);
4018                         curEnv->DeleteLocalRef(cls);
4019 if (curEnv->ExceptionCheck()) {
4020 throw GiwsException::JniCallMethodException(curEnv);
4021 }
4022 }
4023
4024 void CallScilabBridge::launchHelpBrowser (JavaVM * jvm_, char const* const* helps, int helpsSize, char const* language){
4025
4026 JNIEnv * curEnv = NULL;
4027 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4028 jclass cls = curEnv->FindClass( className().c_str() );
4029
4030 jmethodID voidlaunchHelpBrowserjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "launchHelpBrowser", "([Ljava/lang/String;Ljava/lang/String;)V" ) ;
4031 if (voidlaunchHelpBrowserjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_StringID == NULL) {
4032 throw GiwsException::JniMethodNotFoundException(curEnv, "launchHelpBrowser");
4033 }
4034 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
4035
4036 // create java array of strings.
4037 jobjectArray helps_ = curEnv->NewObjectArray( helpsSize, stringArrayClass, NULL);
4038 if (helps_ == NULL)
4039 {
4040 throw GiwsException::JniBadAllocException(curEnv);
4041 }
4042
4043 // convert each char * to java strings and fill the java array.
4044 for ( int i = 0; i < helpsSize; i++)
4045 {
4046 jstring TempString = curEnv->NewStringUTF( helps[i] );
4047 if (TempString == NULL)
4048 {
4049 throw GiwsException::JniBadAllocException(curEnv);
4050 }
4051
4052 curEnv->SetObjectArrayElement( helps_, i, TempString);
4053
4054 // avoid keeping reference on to many strings
4055 curEnv->DeleteLocalRef(TempString);
4056 }
4057 jstring language_ = curEnv->NewStringUTF( language );
4058 if (language != NULL && language_ == NULL)
4059 {
4060 throw GiwsException::JniBadAllocException(curEnv);
4061 }
4062
4063
4064                          curEnv->CallStaticVoidMethod(cls, voidlaunchHelpBrowserjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_StringID ,helps_, language_);
4065                         curEnv->DeleteLocalRef(stringArrayClass);
4066 curEnv->DeleteLocalRef(helps_);
4067 curEnv->DeleteLocalRef(language_);
4068 curEnv->DeleteLocalRef(cls);
4069 if (curEnv->ExceptionCheck()) {
4070 throw GiwsException::JniCallMethodException(curEnv);
4071 }
4072 }
4073
4074 void CallScilabBridge::searchKeyword (JavaVM * jvm_, char const* const* helps, int helpsSize, char const* keyword, char const* language, bool fullText){
4075
4076 JNIEnv * curEnv = NULL;
4077 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4078 jclass cls = curEnv->FindClass( className().c_str() );
4079
4080 jmethodID voidsearchKeywordjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "searchKeyword", "([Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Z)V" ) ;
4081 if (voidsearchKeywordjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID == NULL) {
4082 throw GiwsException::JniMethodNotFoundException(curEnv, "searchKeyword");
4083 }
4084 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
4085
4086 // create java array of strings.
4087 jobjectArray helps_ = curEnv->NewObjectArray( helpsSize, stringArrayClass, NULL);
4088 if (helps_ == NULL)
4089 {
4090 throw GiwsException::JniBadAllocException(curEnv);
4091 }
4092
4093 // convert each char * to java strings and fill the java array.
4094 for ( int i = 0; i < helpsSize; i++)
4095 {
4096 jstring TempString = curEnv->NewStringUTF( helps[i] );
4097 if (TempString == NULL)
4098 {
4099 throw GiwsException::JniBadAllocException(curEnv);
4100 }
4101
4102 curEnv->SetObjectArrayElement( helps_, i, TempString);
4103
4104 // avoid keeping reference on to many strings
4105 curEnv->DeleteLocalRef(TempString);
4106 }
4107 jstring keyword_ = curEnv->NewStringUTF( keyword );
4108 if (keyword != NULL && keyword_ == NULL)
4109 {
4110 throw GiwsException::JniBadAllocException(curEnv);
4111 }
4112
4113
4114 jstring language_ = curEnv->NewStringUTF( language );
4115 if (language != NULL && language_ == NULL)
4116 {
4117 throw GiwsException::JniBadAllocException(curEnv);
4118 }
4119
4120
4121 jboolean fullText_ = (static_cast<bool>(fullText) ? JNI_TRUE : JNI_FALSE);
4122
4123                          curEnv->CallStaticVoidMethod(cls, voidsearchKeywordjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID ,helps_, keyword_, language_, fullText_);
4124                         curEnv->DeleteLocalRef(stringArrayClass);
4125 curEnv->DeleteLocalRef(helps_);
4126 curEnv->DeleteLocalRef(keyword_);
4127 curEnv->DeleteLocalRef(language_);
4128 curEnv->DeleteLocalRef(cls);
4129 if (curEnv->ExceptionCheck()) {
4130 throw GiwsException::JniCallMethodException(curEnv);
4131 }
4132 }
4133
4134 int CallScilabBridge::newExportFileChooser (JavaVM * jvm_, int figureId){
4135
4136 JNIEnv * curEnv = NULL;
4137 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4138 jclass cls = curEnv->FindClass( className().c_str() );
4139
4140 jmethodID jintnewExportFileChooserjintintID = curEnv->GetStaticMethodID(cls, "newExportFileChooser", "(I)I" ) ;
4141 if (jintnewExportFileChooserjintintID == NULL) {
4142 throw GiwsException::JniMethodNotFoundException(curEnv, "newExportFileChooser");
4143 }
4144
4145                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewExportFileChooserjintintID ,figureId));
4146                         curEnv->DeleteLocalRef(cls);
4147 if (curEnv->ExceptionCheck()) {
4148 throw GiwsException::JniCallMethodException(curEnv);
4149 }
4150 return res;
4151
4152 }
4153
4154 int CallScilabBridge::newFontChooser (JavaVM * jvm_){
4155
4156 JNIEnv * curEnv = NULL;
4157 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4158 jclass cls = curEnv->FindClass( className().c_str() );
4159
4160 jmethodID jintnewFontChooserID = curEnv->GetStaticMethodID(cls, "newFontChooser", "()I" ) ;
4161 if (jintnewFontChooserID == NULL) {
4162 throw GiwsException::JniMethodNotFoundException(curEnv, "newFontChooser");
4163 }
4164
4165                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewFontChooserID ));
4166                         curEnv->DeleteLocalRef(cls);
4167 if (curEnv->ExceptionCheck()) {
4168 throw GiwsException::JniCallMethodException(curEnv);
4169 }
4170 return res;
4171
4172 }
4173
4174 void CallScilabBridge::fontChooserDisplayAndWait (JavaVM * jvm_, int objID){
4175
4176 JNIEnv * curEnv = NULL;
4177 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4178 jclass cls = curEnv->FindClass( className().c_str() );
4179
4180 jmethodID voidfontChooserDisplayAndWaitjintintID = curEnv->GetStaticMethodID(cls, "fontChooserDisplayAndWait", "(I)V" ) ;
4181 if (voidfontChooserDisplayAndWaitjintintID == NULL) {
4182 throw GiwsException::JniMethodNotFoundException(curEnv, "fontChooserDisplayAndWait");
4183 }
4184
4185                          curEnv->CallStaticVoidMethod(cls, voidfontChooserDisplayAndWaitjintintID ,objID);
4186                         curEnv->DeleteLocalRef(cls);
4187 if (curEnv->ExceptionCheck()) {
4188 throw GiwsException::JniCallMethodException(curEnv);
4189 }
4190 }
4191
4192 void CallScilabBridge::setFontChooserFontName (JavaVM * jvm_, int objID, char const* fontName){
4193
4194 JNIEnv * curEnv = NULL;
4195 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4196 jclass cls = curEnv->FindClass( className().c_str() );
4197
4198 jmethodID voidsetFontChooserFontNamejintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setFontChooserFontName", "(ILjava/lang/String;)V" ) ;
4199 if (voidsetFontChooserFontNamejintintjstringjava_lang_StringID == NULL) {
4200 throw GiwsException::JniMethodNotFoundException(curEnv, "setFontChooserFontName");
4201 }
4202
4203 jstring fontName_ = curEnv->NewStringUTF( fontName );
4204 if (fontName != NULL && fontName_ == NULL)
4205 {
4206 throw GiwsException::JniBadAllocException(curEnv);
4207 }
4208
4209
4210                          curEnv->CallStaticVoidMethod(cls, voidsetFontChooserFontNamejintintjstringjava_lang_StringID ,objID, fontName_);
4211                         curEnv->DeleteLocalRef(fontName_);
4212 curEnv->DeleteLocalRef(cls);
4213 if (curEnv->ExceptionCheck()) {
4214 throw GiwsException::JniCallMethodException(curEnv);
4215 }
4216 }
4217
4218 void CallScilabBridge::setFontChooserFontSize (JavaVM * jvm_, int objID, int fontSize){
4219
4220 JNIEnv * curEnv = NULL;
4221 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4222 jclass cls = curEnv->FindClass( className().c_str() );
4223
4224 jmethodID voidsetFontChooserFontSizejintintjintintID = curEnv->GetStaticMethodID(cls, "setFontChooserFontSize", "(II)V" ) ;
4225 if (voidsetFontChooserFontSizejintintjintintID == NULL) {
4226 throw GiwsException::JniMethodNotFoundException(curEnv, "setFontChooserFontSize");
4227 }
4228
4229                          curEnv->CallStaticVoidMethod(cls, voidsetFontChooserFontSizejintintjintintID ,objID, fontSize);
4230                         curEnv->DeleteLocalRef(cls);
4231 if (curEnv->ExceptionCheck()) {
4232 throw GiwsException::JniCallMethodException(curEnv);
4233 }
4234 }
4235
4236 void CallScilabBridge::setFontChooserBold (JavaVM * jvm_, int objID, bool bold){
4237
4238 JNIEnv * curEnv = NULL;
4239 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4240 jclass cls = curEnv->FindClass( className().c_str() );
4241
4242 jmethodID voidsetFontChooserBoldjintintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "setFontChooserBold", "(IZ)V" ) ;
4243 if (voidsetFontChooserBoldjintintjbooleanbooleanID == NULL) {
4244 throw GiwsException::JniMethodNotFoundException(curEnv, "setFontChooserBold");
4245 }
4246
4247 jboolean bold_ = (static_cast<bool>(bold) ? JNI_TRUE : JNI_FALSE);
4248
4249                          curEnv->CallStaticVoidMethod(cls, voidsetFontChooserBoldjintintjbooleanbooleanID ,objID, bold_);
4250                         curEnv->DeleteLocalRef(cls);
4251 if (curEnv->ExceptionCheck()) {
4252 throw GiwsException::JniCallMethodException(curEnv);
4253 }
4254 }
4255
4256 void CallScilabBridge::setFontChooserItalic (JavaVM * jvm_, int objID, bool italic){
4257
4258 JNIEnv * curEnv = NULL;
4259 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4260 jclass cls = curEnv->FindClass( className().c_str() );
4261
4262 jmethodID voidsetFontChooserItalicjintintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "setFontChooserItalic", "(IZ)V" ) ;
4263 if (voidsetFontChooserItalicjintintjbooleanbooleanID == NULL) {
4264 throw GiwsException::JniMethodNotFoundException(curEnv, "setFontChooserItalic");
4265 }
4266
4267 jboolean italic_ = (static_cast<bool>(italic) ? JNI_TRUE : JNI_FALSE);
4268
4269                          curEnv->CallStaticVoidMethod(cls, voidsetFontChooserItalicjintintjbooleanbooleanID ,objID, italic_);
4270                         curEnv->DeleteLocalRef(cls);
4271 if (curEnv->ExceptionCheck()) {
4272 throw GiwsException::JniCallMethodException(curEnv);
4273 }
4274 }
4275
4276 char* CallScilabBridge::getFontChooserFontName (JavaVM * jvm_, int objID){
4277
4278 JNIEnv * curEnv = NULL;
4279 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4280 jclass cls = curEnv->FindClass( className().c_str() );
4281
4282 jmethodID jstringgetFontChooserFontNamejintintID = curEnv->GetStaticMethodID(cls, "getFontChooserFontName", "(I)Ljava/lang/String;" ) ;
4283 if (jstringgetFontChooserFontNamejintintID == NULL) {
4284 throw GiwsException::JniMethodNotFoundException(curEnv, "getFontChooserFontName");
4285 }
4286
4287                         jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringgetFontChooserFontNamejintintID ,objID));
4288                         if (curEnv->ExceptionCheck()) {
4289 throw GiwsException::JniCallMethodException(curEnv);
4290 }
4291
4292 const char *tempString = curEnv->GetStringUTFChars(res, 0);
4293 char * myStringBuffer = new char[strlen(tempString) + 1];
4294 strcpy(myStringBuffer, tempString);
4295 curEnv->ReleaseStringUTFChars(res, tempString);
4296 curEnv->DeleteLocalRef(res);
4297 curEnv->DeleteLocalRef(cls);
4298 if (curEnv->ExceptionCheck()) {
4299 delete[] myStringBuffer;
4300                                 throw GiwsException::JniCallMethodException(curEnv);
4301 }
4302 return myStringBuffer;
4303
4304 }
4305
4306 int CallScilabBridge::getFontChooserFontSize (JavaVM * jvm_, int objID){
4307
4308 JNIEnv * curEnv = NULL;
4309 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4310 jclass cls = curEnv->FindClass( className().c_str() );
4311
4312 jmethodID jintgetFontChooserFontSizejintintID = curEnv->GetStaticMethodID(cls, "getFontChooserFontSize", "(I)I" ) ;
4313 if (jintgetFontChooserFontSizejintintID == NULL) {
4314 throw GiwsException::JniMethodNotFoundException(curEnv, "getFontChooserFontSize");
4315 }
4316
4317                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetFontChooserFontSizejintintID ,objID));
4318                         curEnv->DeleteLocalRef(cls);
4319 if (curEnv->ExceptionCheck()) {
4320 throw GiwsException::JniCallMethodException(curEnv);
4321 }
4322 return res;
4323
4324 }
4325
4326 bool CallScilabBridge::getFontChooserBold (JavaVM * jvm_, int objID){
4327
4328 JNIEnv * curEnv = NULL;
4329 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4330 jclass cls = curEnv->FindClass( className().c_str() );
4331
4332 jmethodID jbooleangetFontChooserBoldjintintID = curEnv->GetStaticMethodID(cls, "getFontChooserBold", "(I)Z" ) ;
4333 if (jbooleangetFontChooserBoldjintintID == NULL) {
4334 throw GiwsException::JniMethodNotFoundException(curEnv, "getFontChooserBold");
4335 }
4336
4337                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleangetFontChooserBoldjintintID ,objID));
4338                         curEnv->DeleteLocalRef(cls);
4339 if (curEnv->ExceptionCheck()) {
4340 throw GiwsException::JniCallMethodException(curEnv);
4341 }
4342 return (res == JNI_TRUE);
4343
4344 }
4345
4346 bool CallScilabBridge::getFontChooserItalic (JavaVM * jvm_, int objID){
4347
4348 JNIEnv * curEnv = NULL;
4349 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4350 jclass cls = curEnv->FindClass( className().c_str() );
4351
4352 jmethodID jbooleangetFontChooserItalicjintintID = curEnv->GetStaticMethodID(cls, "getFontChooserItalic", "(I)Z" ) ;
4353 if (jbooleangetFontChooserItalicjintintID == NULL) {
4354 throw GiwsException::JniMethodNotFoundException(curEnv, "getFontChooserItalic");
4355 }
4356
4357                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleangetFontChooserItalicjintintID ,objID));
4358                         curEnv->DeleteLocalRef(cls);
4359 if (curEnv->ExceptionCheck()) {
4360 throw GiwsException::JniCallMethodException(curEnv);
4361 }
4362 return (res == JNI_TRUE);
4363
4364 }
4365
4366 int CallScilabBridge::newColorChooser (JavaVM * jvm_){
4367
4368 JNIEnv * curEnv = NULL;
4369 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4370 jclass cls = curEnv->FindClass( className().c_str() );
4371
4372 jmethodID jintnewColorChooserID = curEnv->GetStaticMethodID(cls, "newColorChooser", "()I" ) ;
4373 if (jintnewColorChooserID == NULL) {
4374 throw GiwsException::JniMethodNotFoundException(curEnv, "newColorChooser");
4375 }
4376
4377                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewColorChooserID ));
4378                         curEnv->DeleteLocalRef(cls);
4379 if (curEnv->ExceptionCheck()) {
4380 throw GiwsException::JniCallMethodException(curEnv);
4381 }
4382 return res;
4383
4384 }
4385
4386 void CallScilabBridge::colorChooserDisplayAndWait (JavaVM * jvm_, int objID){
4387
4388 JNIEnv * curEnv = NULL;
4389 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4390 jclass cls = curEnv->FindClass( className().c_str() );
4391
4392 jmethodID voidcolorChooserDisplayAndWaitjintintID = curEnv->GetStaticMethodID(cls, "colorChooserDisplayAndWait", "(I)V" ) ;
4393 if (voidcolorChooserDisplayAndWaitjintintID == NULL) {
4394 throw GiwsException::JniMethodNotFoundException(curEnv, "colorChooserDisplayAndWait");
4395 }
4396
4397                          curEnv->CallStaticVoidMethod(cls, voidcolorChooserDisplayAndWaitjintintID ,objID);
4398                         curEnv->DeleteLocalRef(cls);
4399 if (curEnv->ExceptionCheck()) {
4400 throw GiwsException::JniCallMethodException(curEnv);
4401 }
4402 }
4403
4404 void CallScilabBridge::setColorChooserDefaultColor (JavaVM * jvm_, int objID, int const* rgb, int rgbSize){
4405
4406 JNIEnv * curEnv = NULL;
4407 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4408 jclass cls = curEnv->FindClass( className().c_str() );
4409
4410 jmethodID voidsetColorChooserDefaultColorjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "setColorChooserDefaultColor", "(I[I)V" ) ;
4411 if (voidsetColorChooserDefaultColorjintintjintArray_intintID == NULL) {
4412 throw GiwsException::JniMethodNotFoundException(curEnv, "setColorChooserDefaultColor");
4413 }
4414
4415 jintArray rgb_ = curEnv->NewIntArray( rgbSize ) ;
4416
4417 if (rgb_ == NULL)
4418 {
4419 // check that allocation succeed
4420 throw GiwsException::JniBadAllocException(curEnv);
4421 }
4422
4423 curEnv->SetIntArrayRegion( rgb_, 0, rgbSize, (jint*)(rgb) ) ;
4424
4425
4426                          curEnv->CallStaticVoidMethod(cls, voidsetColorChooserDefaultColorjintintjintArray_intintID ,objID, rgb_);
4427                         curEnv->DeleteLocalRef(rgb_);
4428 curEnv->DeleteLocalRef(cls);
4429 if (curEnv->ExceptionCheck()) {
4430 throw GiwsException::JniCallMethodException(curEnv);
4431 }
4432 }
4433
4434 int* CallScilabBridge::getColorChooserSelectedColor (JavaVM * jvm_, int objID){
4435
4436 JNIEnv * curEnv = NULL;
4437 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4438 jclass cls = curEnv->FindClass( className().c_str() );
4439
4440 jmethodID jintArray_getColorChooserSelectedColorjintintID = curEnv->GetStaticMethodID(cls, "getColorChooserSelectedColor", "(I)[I" ) ;
4441 if (jintArray_getColorChooserSelectedColorjintintID == NULL) {
4442 throw GiwsException::JniMethodNotFoundException(curEnv, "getColorChooserSelectedColor");
4443 }
4444
4445                         jintArray res =  static_cast<jintArray>( curEnv->CallStaticObjectMethod(cls, jintArray_getColorChooserSelectedColorjintintID ,objID));
4446                         if (res == NULL) { return NULL; }
4447                         if (curEnv->ExceptionCheck()) {
4448 throw GiwsException::JniCallMethodException(curEnv);
4449 }int lenRow;
4450  lenRow = curEnv->GetArrayLength(res);
4451 jboolean isCopy = JNI_FALSE;
4452
4453 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
4454 jint *resultsArray = static_cast<jint *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
4455 int* myArray= new int[ lenRow];
4456
4457 for (jsize i = 0; i <  lenRow; i++){
4458 myArray[i]=resultsArray[i];
4459 }
4460 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
4461
4462                         curEnv->DeleteLocalRef(res);
4463 curEnv->DeleteLocalRef(cls);
4464 if (curEnv->ExceptionCheck()) {
4465 delete[] myArray;
4466                                 throw GiwsException::JniCallMethodException(curEnv);
4467 }
4468 return myArray;
4469
4470 }
4471
4472 void CallScilabBridge::setColorChooserTitle (JavaVM * jvm_, int objID, char const* title){
4473
4474 JNIEnv * curEnv = NULL;
4475 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4476 jclass cls = curEnv->FindClass( className().c_str() );
4477
4478 jmethodID voidsetColorChooserTitlejintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setColorChooserTitle", "(ILjava/lang/String;)V" ) ;
4479 if (voidsetColorChooserTitlejintintjstringjava_lang_StringID == NULL) {
4480 throw GiwsException::JniMethodNotFoundException(curEnv, "setColorChooserTitle");
4481 }
4482
4483 jstring title_ = curEnv->NewStringUTF( title );
4484 if (title != NULL && title_ == NULL)
4485 {
4486 throw GiwsException::JniBadAllocException(curEnv);
4487 }
4488
4489
4490                          curEnv->CallStaticVoidMethod(cls, voidsetColorChooserTitlejintintjstringjava_lang_StringID ,objID, title_);
4491                         curEnv->DeleteLocalRef(title_);
4492 curEnv->DeleteLocalRef(cls);
4493 if (curEnv->ExceptionCheck()) {
4494 throw GiwsException::JniCallMethodException(curEnv);
4495 }
4496 }
4497
4498 void CallScilabBridge::setWidgetVisible (JavaVM * jvm_, int objID, bool status){
4499
4500 JNIEnv * curEnv = NULL;
4501 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4502 jclass cls = curEnv->FindClass( className().c_str() );
4503
4504 jmethodID voidsetWidgetVisiblejintintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "setWidgetVisible", "(IZ)V" ) ;
4505 if (voidsetWidgetVisiblejintintjbooleanbooleanID == NULL) {
4506 throw GiwsException::JniMethodNotFoundException(curEnv, "setWidgetVisible");
4507 }
4508
4509 jboolean status_ = (static_cast<bool>(status) ? JNI_TRUE : JNI_FALSE);
4510
4511                          curEnv->CallStaticVoidMethod(cls, voidsetWidgetVisiblejintintjbooleanbooleanID ,objID, status_);
4512                         curEnv->DeleteLocalRef(cls);
4513 if (curEnv->ExceptionCheck()) {
4514 throw GiwsException::JniCallMethodException(curEnv);
4515 }
4516 }
4517
4518 void CallScilabBridge::setFrameVisible (JavaVM * jvm_, int objID, bool status){
4519
4520 JNIEnv * curEnv = NULL;
4521 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4522 jclass cls = curEnv->FindClass( className().c_str() );
4523
4524 jmethodID voidsetFrameVisiblejintintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "setFrameVisible", "(IZ)V" ) ;
4525 if (voidsetFrameVisiblejintintjbooleanbooleanID == NULL) {
4526 throw GiwsException::JniMethodNotFoundException(curEnv, "setFrameVisible");
4527 }
4528
4529 jboolean status_ = (static_cast<bool>(status) ? JNI_TRUE : JNI_FALSE);
4530
4531                          curEnv->CallStaticVoidMethod(cls, voidsetFrameVisiblejintintjbooleanbooleanID ,objID, status_);
4532                         curEnv->DeleteLocalRef(cls);
4533 if (curEnv->ExceptionCheck()) {
4534 throw GiwsException::JniCallMethodException(curEnv);
4535 }
4536 }
4537
4538 bool CallScilabBridge::isWidgetVisible (JavaVM * jvm_, int objID){
4539
4540 JNIEnv * curEnv = NULL;
4541 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4542 jclass cls = curEnv->FindClass( className().c_str() );
4543
4544 jmethodID jbooleanisWidgetVisiblejintintID = curEnv->GetStaticMethodID(cls, "isWidgetVisible", "(I)Z" ) ;
4545 if (jbooleanisWidgetVisiblejintintID == NULL) {
4546 throw GiwsException::JniMethodNotFoundException(curEnv, "isWidgetVisible");
4547 }
4548
4549                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanisWidgetVisiblejintintID ,objID));
4550                         curEnv->DeleteLocalRef(cls);
4551 if (curEnv->ExceptionCheck()) {
4552 throw GiwsException::JniCallMethodException(curEnv);
4553 }
4554 return (res == JNI_TRUE);
4555
4556 }
4557
4558 bool CallScilabBridge::isFrameVisible (JavaVM * jvm_, int objID){
4559
4560 JNIEnv * curEnv = NULL;
4561 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4562 jclass cls = curEnv->FindClass( className().c_str() );
4563
4564 jmethodID jbooleanisFrameVisiblejintintID = curEnv->GetStaticMethodID(cls, "isFrameVisible", "(I)Z" ) ;
4565 if (jbooleanisFrameVisiblejintintID == NULL) {
4566 throw GiwsException::JniMethodNotFoundException(curEnv, "isFrameVisible");
4567 }
4568
4569                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanisFrameVisiblejintintID ,objID));
4570                         curEnv->DeleteLocalRef(cls);
4571 if (curEnv->ExceptionCheck()) {
4572 throw GiwsException::JniCallMethodException(curEnv);
4573 }
4574 return (res == JNI_TRUE);
4575
4576 }
4577
4578 char* CallScilabBridge::getClipboardContents (JavaVM * jvm_){
4579
4580 JNIEnv * curEnv = NULL;
4581 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4582 jclass cls = curEnv->FindClass( className().c_str() );
4583
4584 jmethodID jstringgetClipboardContentsID = curEnv->GetStaticMethodID(cls, "getClipboardContents", "()Ljava/lang/String;" ) ;
4585 if (jstringgetClipboardContentsID == NULL) {
4586 throw GiwsException::JniMethodNotFoundException(curEnv, "getClipboardContents");
4587 }
4588
4589                         jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringgetClipboardContentsID ));
4590                         if (curEnv->ExceptionCheck()) {
4591 throw GiwsException::JniCallMethodException(curEnv);
4592 }
4593
4594 const char *tempString = curEnv->GetStringUTFChars(res, 0);
4595 char * myStringBuffer = new char[strlen(tempString) + 1];
4596 strcpy(myStringBuffer, tempString);
4597 curEnv->ReleaseStringUTFChars(res, tempString);
4598 curEnv->DeleteLocalRef(res);
4599 curEnv->DeleteLocalRef(cls);
4600 if (curEnv->ExceptionCheck()) {
4601 delete[] myStringBuffer;
4602                                 throw GiwsException::JniCallMethodException(curEnv);
4603 }
4604 return myStringBuffer;
4605
4606 }
4607
4608 void CallScilabBridge::pasteClipboardIntoConsole (JavaVM * jvm_){
4609
4610 JNIEnv * curEnv = NULL;
4611 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4612 jclass cls = curEnv->FindClass( className().c_str() );
4613
4614 jmethodID voidpasteClipboardIntoConsoleID = curEnv->GetStaticMethodID(cls, "pasteClipboardIntoConsole", "()V" ) ;
4615 if (voidpasteClipboardIntoConsoleID == NULL) {
4616 throw GiwsException::JniMethodNotFoundException(curEnv, "pasteClipboardIntoConsole");
4617 }
4618
4619                          curEnv->CallStaticVoidMethod(cls, voidpasteClipboardIntoConsoleID );
4620                         curEnv->DeleteLocalRef(cls);
4621 if (curEnv->ExceptionCheck()) {
4622 throw GiwsException::JniCallMethodException(curEnv);
4623 }
4624 }
4625
4626 void CallScilabBridge::copyConsoleSelection (JavaVM * jvm_){
4627
4628 JNIEnv * curEnv = NULL;
4629 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4630 jclass cls = curEnv->FindClass( className().c_str() );
4631
4632 jmethodID voidcopyConsoleSelectionID = curEnv->GetStaticMethodID(cls, "copyConsoleSelection", "()V" ) ;
4633 if (voidcopyConsoleSelectionID == NULL) {
4634 throw GiwsException::JniMethodNotFoundException(curEnv, "copyConsoleSelection");
4635 }
4636
4637                          curEnv->CallStaticVoidMethod(cls, voidcopyConsoleSelectionID );
4638                         curEnv->DeleteLocalRef(cls);
4639 if (curEnv->ExceptionCheck()) {
4640 throw GiwsException::JniCallMethodException(curEnv);
4641 }
4642 }
4643
4644 void CallScilabBridge::emptyClipboard (JavaVM * jvm_){
4645
4646 JNIEnv * curEnv = NULL;
4647 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4648 jclass cls = curEnv->FindClass( className().c_str() );
4649
4650 jmethodID voidemptyClipboardID = curEnv->GetStaticMethodID(cls, "emptyClipboard", "()V" ) ;
4651 if (voidemptyClipboardID == NULL) {
4652 throw GiwsException::JniMethodNotFoundException(curEnv, "emptyClipboard");
4653 }
4654
4655                          curEnv->CallStaticVoidMethod(cls, voidemptyClipboardID );
4656                         curEnv->DeleteLocalRef(cls);
4657 if (curEnv->ExceptionCheck()) {
4658 throw GiwsException::JniCallMethodException(curEnv);
4659 }
4660 }
4661
4662 void CallScilabBridge::setClipboardContents (JavaVM * jvm_, char const* text){
4663
4664 JNIEnv * curEnv = NULL;
4665 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4666 jclass cls = curEnv->FindClass( className().c_str() );
4667
4668 jmethodID voidsetClipboardContentsjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setClipboardContents", "(Ljava/lang/String;)V" ) ;
4669 if (voidsetClipboardContentsjstringjava_lang_StringID == NULL) {
4670 throw GiwsException::JniMethodNotFoundException(curEnv, "setClipboardContents");
4671 }
4672
4673 jstring text_ = curEnv->NewStringUTF( text );
4674 if (text != NULL && text_ == NULL)
4675 {
4676 throw GiwsException::JniBadAllocException(curEnv);
4677 }
4678
4679
4680                          curEnv->CallStaticVoidMethod(cls, voidsetClipboardContentsjstringjava_lang_StringID ,text_);
4681                         curEnv->DeleteLocalRef(text_);
4682 curEnv->DeleteLocalRef(cls);
4683 if (curEnv->ExceptionCheck()) {
4684 throw GiwsException::JniCallMethodException(curEnv);
4685 }
4686 }
4687
4688 void CallScilabBridge::copyFigureToClipBoard (JavaVM * jvm_, int figID){
4689
4690 JNIEnv * curEnv = NULL;
4691 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4692 jclass cls = curEnv->FindClass( className().c_str() );
4693
4694 jmethodID voidcopyFigureToClipBoardjintintID = curEnv->GetStaticMethodID(cls, "copyFigureToClipBoard", "(I)V" ) ;
4695 if (voidcopyFigureToClipBoardjintintID == NULL) {
4696 throw GiwsException::JniMethodNotFoundException(curEnv, "copyFigureToClipBoard");
4697 }
4698
4699                          curEnv->CallStaticVoidMethod(cls, voidcopyFigureToClipBoardjintintID ,figID);
4700                         curEnv->DeleteLocalRef(cls);
4701 if (curEnv->ExceptionCheck()) {
4702 throw GiwsException::JniCallMethodException(curEnv);
4703 }
4704 }
4705
4706 int CallScilabBridge::getScreenResolution (JavaVM * jvm_){
4707
4708 JNIEnv * curEnv = NULL;
4709 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4710 jclass cls = curEnv->FindClass( className().c_str() );
4711
4712 jmethodID jintgetScreenResolutionID = curEnv->GetStaticMethodID(cls, "getScreenResolution", "()I" ) ;
4713 if (jintgetScreenResolutionID == NULL) {
4714 throw GiwsException::JniMethodNotFoundException(curEnv, "getScreenResolution");
4715 }
4716
4717                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetScreenResolutionID ));
4718                         curEnv->DeleteLocalRef(cls);
4719 if (curEnv->ExceptionCheck()) {
4720 throw GiwsException::JniCallMethodException(curEnv);
4721 }
4722 return res;
4723
4724 }
4725
4726 double CallScilabBridge::getScreenWidth (JavaVM * jvm_){
4727
4728 JNIEnv * curEnv = NULL;
4729 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4730 jclass cls = curEnv->FindClass( className().c_str() );
4731
4732 jmethodID jdoublegetScreenWidthID = curEnv->GetStaticMethodID(cls, "getScreenWidth", "()D" ) ;
4733 if (jdoublegetScreenWidthID == NULL) {
4734 throw GiwsException::JniMethodNotFoundException(curEnv, "getScreenWidth");
4735 }
4736
4737                         jdouble res =  static_cast<jdouble>( curEnv->CallStaticDoubleMethod(cls, jdoublegetScreenWidthID ));
4738                         curEnv->DeleteLocalRef(cls);
4739 if (curEnv->ExceptionCheck()) {
4740 throw GiwsException::JniCallMethodException(curEnv);
4741 }
4742 return res;
4743
4744 }
4745
4746 double CallScilabBridge::getScreenHeight (JavaVM * jvm_){
4747
4748 JNIEnv * curEnv = NULL;
4749 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4750 jclass cls = curEnv->FindClass( className().c_str() );
4751
4752 jmethodID jdoublegetScreenHeightID = curEnv->GetStaticMethodID(cls, "getScreenHeight", "()D" ) ;
4753 if (jdoublegetScreenHeightID == NULL) {
4754 throw GiwsException::JniMethodNotFoundException(curEnv, "getScreenHeight");
4755 }
4756
4757                         jdouble res =  static_cast<jdouble>( curEnv->CallStaticDoubleMethod(cls, jdoublegetScreenHeightID ));
4758                         curEnv->DeleteLocalRef(cls);
4759 if (curEnv->ExceptionCheck()) {
4760 throw GiwsException::JniCallMethodException(curEnv);
4761 }
4762 return res;
4763
4764 }
4765
4766 int CallScilabBridge::getScreenDepth (JavaVM * jvm_){
4767
4768 JNIEnv * curEnv = NULL;
4769 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4770 jclass cls = curEnv->FindClass( className().c_str() );
4771
4772 jmethodID jintgetScreenDepthID = curEnv->GetStaticMethodID(cls, "getScreenDepth", "()I" ) ;
4773 if (jintgetScreenDepthID == NULL) {
4774 throw GiwsException::JniMethodNotFoundException(curEnv, "getScreenDepth");
4775 }
4776
4777                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetScreenDepthID ));
4778                         curEnv->DeleteLocalRef(cls);
4779 if (curEnv->ExceptionCheck()) {
4780 throw GiwsException::JniCallMethodException(curEnv);
4781 }
4782 return res;
4783
4784 }
4785
4786 bool CallScilabBridge::printFigure (JavaVM * jvm_, int figID, bool postScript, bool displayDialog){
4787
4788 JNIEnv * curEnv = NULL;
4789 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4790 jclass cls = curEnv->FindClass( className().c_str() );
4791
4792 jmethodID jbooleanprintFigurejintintjbooleanbooleanjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "printFigure", "(IZZ)Z" ) ;
4793 if (jbooleanprintFigurejintintjbooleanbooleanjbooleanbooleanID == NULL) {
4794 throw GiwsException::JniMethodNotFoundException(curEnv, "printFigure");
4795 }
4796
4797 jboolean postScript_ = (static_cast<bool>(postScript) ? JNI_TRUE : JNI_FALSE);
4798
4799 jboolean displayDialog_ = (static_cast<bool>(displayDialog) ? JNI_TRUE : JNI_FALSE);
4800
4801                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanprintFigurejintintjbooleanbooleanjbooleanbooleanID ,figID, postScript_, displayDialog_));
4802                         curEnv->DeleteLocalRef(cls);
4803 if (curEnv->ExceptionCheck()) {
4804 throw GiwsException::JniCallMethodException(curEnv);
4805 }
4806 return (res == JNI_TRUE);
4807
4808 }
4809
4810 bool CallScilabBridge::printFile (JavaVM * jvm_, char const* fileName){
4811
4812 JNIEnv * curEnv = NULL;
4813 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4814 jclass cls = curEnv->FindClass( className().c_str() );
4815
4816 jmethodID jbooleanprintFilejstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "printFile", "(Ljava/lang/String;)Z" ) ;
4817 if (jbooleanprintFilejstringjava_lang_StringID == NULL) {
4818 throw GiwsException::JniMethodNotFoundException(curEnv, "printFile");
4819 }
4820
4821 jstring fileName_ = curEnv->NewStringUTF( fileName );
4822 if (fileName != NULL && fileName_ == NULL)
4823 {
4824 throw GiwsException::JniBadAllocException(curEnv);
4825 }
4826
4827
4828                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanprintFilejstringjava_lang_StringID ,fileName_));
4829                         curEnv->DeleteLocalRef(fileName_);
4830 curEnv->DeleteLocalRef(cls);
4831 if (curEnv->ExceptionCheck()) {
4832 throw GiwsException::JniCallMethodException(curEnv);
4833 }
4834 return (res == JNI_TRUE);
4835
4836 }
4837
4838 bool CallScilabBridge::printString (JavaVM * jvm_, char const* theString, char const* pageHeader){
4839
4840 JNIEnv * curEnv = NULL;
4841 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4842 jclass cls = curEnv->FindClass( className().c_str() );
4843
4844 jmethodID jbooleanprintStringjstringjava_lang_Stringjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "printString", "(Ljava/lang/String;Ljava/lang/String;)Z" ) ;
4845 if (jbooleanprintStringjstringjava_lang_Stringjstringjava_lang_StringID == NULL) {
4846 throw GiwsException::JniMethodNotFoundException(curEnv, "printString");
4847 }
4848
4849 jstring theString_ = curEnv->NewStringUTF( theString );
4850 if (theString != NULL && theString_ == NULL)
4851 {
4852 throw GiwsException::JniBadAllocException(curEnv);
4853 }
4854
4855
4856 jstring pageHeader_ = curEnv->NewStringUTF( pageHeader );
4857 if (pageHeader != NULL && pageHeader_ == NULL)
4858 {
4859 throw GiwsException::JniBadAllocException(curEnv);
4860 }
4861
4862
4863                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanprintStringjstringjava_lang_Stringjstringjava_lang_StringID ,theString_, pageHeader_));
4864                         curEnv->DeleteLocalRef(theString_);
4865 curEnv->DeleteLocalRef(pageHeader_);
4866 curEnv->DeleteLocalRef(cls);
4867 if (curEnv->ExceptionCheck()) {
4868 throw GiwsException::JniCallMethodException(curEnv);
4869 }
4870 return (res == JNI_TRUE);
4871
4872 }
4873
4874 bool CallScilabBridge::pageSetup (JavaVM * jvm_){
4875
4876 JNIEnv * curEnv = NULL;
4877 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4878 jclass cls = curEnv->FindClass( className().c_str() );
4879
4880 jmethodID jbooleanpageSetupID = curEnv->GetStaticMethodID(cls, "pageSetup", "()Z" ) ;
4881 if (jbooleanpageSetupID == NULL) {
4882 throw GiwsException::JniMethodNotFoundException(curEnv, "pageSetup");
4883 }
4884
4885                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanpageSetupID ));
4886                         curEnv->DeleteLocalRef(cls);
4887 if (curEnv->ExceptionCheck()) {
4888 throw GiwsException::JniCallMethodException(curEnv);
4889 }
4890 return (res == JNI_TRUE);
4891
4892 }
4893
4894 void CallScilabBridge::requestFocus (JavaVM * jvm_, char const* objUID){
4895
4896 JNIEnv * curEnv = NULL;
4897 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4898 jclass cls = curEnv->FindClass( className().c_str() );
4899
4900 jmethodID voidrequestFocusjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "requestFocus", "(Ljava/lang/String;)V" ) ;
4901 if (voidrequestFocusjstringjava_lang_StringID == NULL) {
4902 throw GiwsException::JniMethodNotFoundException(curEnv, "requestFocus");
4903 }
4904
4905 jstring objUID_ = curEnv->NewStringUTF( objUID );
4906 if (objUID != NULL && objUID_ == NULL)
4907 {
4908 throw GiwsException::JniBadAllocException(curEnv);
4909 }
4910
4911
4912                          curEnv->CallStaticVoidMethod(cls, voidrequestFocusjstringjava_lang_StringID ,objUID_);
4913                         curEnv->DeleteLocalRef(objUID_);
4914 curEnv->DeleteLocalRef(cls);
4915 if (curEnv->ExceptionCheck()) {
4916 throw GiwsException::JniCallMethodException(curEnv);
4917 }
4918 }
4919
4920 void CallScilabBridge::raiseWindow (JavaVM * jvm_, int objID){
4921
4922 JNIEnv * curEnv = NULL;
4923 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4924 jclass cls = curEnv->FindClass( className().c_str() );
4925
4926 jmethodID voidraiseWindowjintintID = curEnv->GetStaticMethodID(cls, "raiseWindow", "(I)V" ) ;
4927 if (voidraiseWindowjintintID == NULL) {
4928 throw GiwsException::JniMethodNotFoundException(curEnv, "raiseWindow");
4929 }
4930
4931                          curEnv->CallStaticVoidMethod(cls, voidraiseWindowjintintID ,objID);
4932                         curEnv->DeleteLocalRef(cls);
4933 if (curEnv->ExceptionCheck()) {
4934 throw GiwsException::JniCallMethodException(curEnv);
4935 }
4936 }
4937
4938 void CallScilabBridge::useCanvasForDisplay (JavaVM * jvm_, bool onOrOff){
4939
4940 JNIEnv * curEnv = NULL;
4941 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4942 jclass cls = curEnv->FindClass( className().c_str() );
4943
4944 jmethodID voiduseCanvasForDisplayjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "useCanvasForDisplay", "(Z)V" ) ;
4945 if (voiduseCanvasForDisplayjbooleanbooleanID == NULL) {
4946 throw GiwsException::JniMethodNotFoundException(curEnv, "useCanvasForDisplay");
4947 }
4948
4949 jboolean onOrOff_ = (static_cast<bool>(onOrOff) ? JNI_TRUE : JNI_FALSE);
4950
4951                          curEnv->CallStaticVoidMethod(cls, voiduseCanvasForDisplayjbooleanbooleanID ,onOrOff_);
4952                         curEnv->DeleteLocalRef(cls);
4953 if (curEnv->ExceptionCheck()) {
4954 throw GiwsException::JniCallMethodException(curEnv);
4955 }
4956 }
4957
4958 bool CallScilabBridge::useCanvasForDisplay (JavaVM * jvm_){
4959
4960 JNIEnv * curEnv = NULL;
4961 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4962 jclass cls = curEnv->FindClass( className().c_str() );
4963
4964 jmethodID jbooleanuseCanvasForDisplayID = curEnv->GetStaticMethodID(cls, "useCanvasForDisplay", "()Z" ) ;
4965 if (jbooleanuseCanvasForDisplayID == NULL) {
4966 throw GiwsException::JniMethodNotFoundException(curEnv, "useCanvasForDisplay");
4967 }
4968
4969                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanuseCanvasForDisplayID ));
4970                         curEnv->DeleteLocalRef(cls);
4971 if (curEnv->ExceptionCheck()) {
4972 throw GiwsException::JniCallMethodException(curEnv);
4973 }
4974 return (res == JNI_TRUE);
4975
4976 }
4977
4978 void CallScilabBridge::scilabAboutBox (JavaVM * jvm_){
4979
4980 JNIEnv * curEnv = NULL;
4981 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
4982 jclass cls = curEnv->FindClass( className().c_str() );
4983
4984 jmethodID voidscilabAboutBoxID = curEnv->GetStaticMethodID(cls, "scilabAboutBox", "()V" ) ;
4985 if (voidscilabAboutBoxID == NULL) {
4986 throw GiwsException::JniMethodNotFoundException(curEnv, "scilabAboutBox");
4987 }
4988
4989                          curEnv->CallStaticVoidMethod(cls, voidscilabAboutBoxID );
4990                         curEnv->DeleteLocalRef(cls);
4991 if (curEnv->ExceptionCheck()) {
4992 throw GiwsException::JniCallMethodException(curEnv);
4993 }
4994 }
4995
4996 void CallScilabBridge::setUiTableColnames (JavaVM * jvm_, int objID, char const* text){
4997
4998 JNIEnv * curEnv = NULL;
4999 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
5000 jclass cls = curEnv->FindClass( className().c_str() );
5001
5002 jmethodID voidsetUiTableColnamesjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setUiTableColnames", "(ILjava/lang/String;)V" ) ;
5003 if (voidsetUiTableColnamesjintintjstringjava_lang_StringID == NULL) {
5004 throw GiwsException::JniMethodNotFoundException(curEnv, "setUiTableColnames");
5005 }
5006
5007 jstring text_ = curEnv->NewStringUTF( text );
5008 if (text != NULL && text_ == NULL)
5009 {
5010 throw GiwsException::JniBadAllocException(curEnv);
5011 }
5012
5013
5014                          curEnv->CallStaticVoidMethod(cls, voidsetUiTableColnamesjintintjstringjava_lang_StringID ,objID, text_);
5015                         curEnv->DeleteLocalRef(text_);
5016 curEnv->DeleteLocalRef(cls);
5017 if (curEnv->ExceptionCheck()) {
5018 throw GiwsException::JniCallMethodException(curEnv);
5019 }
5020 }
5021
5022 void CallScilabBridge::setUiTableRownames (JavaVM * jvm_, int objID, char const* text){
5023
5024 JNIEnv * curEnv = NULL;
5025 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
5026 jclass cls = curEnv->FindClass( className().c_str() );
5027
5028 jmethodID voidsetUiTableRownamesjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setUiTableRownames", "(ILjava/lang/String;)V" ) ;
5029 if (voidsetUiTableRownamesjintintjstringjava_lang_StringID == NULL) {
5030 throw GiwsException::JniMethodNotFoundException(curEnv, "setUiTableRownames");
5031 }
5032
5033 jstring text_ = curEnv->NewStringUTF( text );
5034 if (text != NULL && text_ == NULL)
5035 {
5036 throw GiwsException::JniBadAllocException(curEnv);
5037 }
5038
5039
5040                          curEnv->CallStaticVoidMethod(cls, voidsetUiTableRownamesjintintjstringjava_lang_StringID ,objID, text_);
5041                         curEnv->DeleteLocalRef(text_);
5042 curEnv->DeleteLocalRef(cls);
5043 if (curEnv->ExceptionCheck()) {
5044 throw GiwsException::JniCallMethodException(curEnv);
5045 }
5046 }
5047
5048 void CallScilabBridge::setUiTableData (JavaVM * jvm_, int objID, char const* text){
5049
5050 JNIEnv * curEnv = NULL;
5051 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
5052 jclass cls = curEnv->FindClass( className().c_str() );
5053
5054 jmethodID voidsetUiTableDatajintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setUiTableData", "(ILjava/lang/String;)V" ) ;
5055 if (voidsetUiTableDatajintintjstringjava_lang_StringID == NULL) {
5056 throw GiwsException::JniMethodNotFoundException(curEnv, "setUiTableData");
5057 }
5058
5059 jstring text_ = curEnv->NewStringUTF( text );
5060 if (text != NULL && text_ == NULL)
5061 {
5062 throw GiwsException::JniBadAllocException(curEnv);
5063 }
5064
5065
5066                          curEnv->CallStaticVoidMethod(cls, voidsetUiTableDatajintintjstringjava_lang_StringID ,objID, text_);
5067                         curEnv->DeleteLocalRef(text_);
5068 curEnv->DeleteLocalRef(cls);
5069 if (curEnv->ExceptionCheck()) {
5070 throw GiwsException::JniCallMethodException(curEnv);
5071 }
5072 }
5073
5074 void CallScilabBridge::setUiTreeData (JavaVM * jvm_, int objID, char const* const* text, int textSize){
5075
5076 JNIEnv * curEnv = NULL;
5077 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
5078 jclass cls = curEnv->FindClass( className().c_str() );
5079
5080 jmethodID voidsetUiTreeDatajintintjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setUiTreeData", "(I[Ljava/lang/String;)V" ) ;
5081 if (voidsetUiTreeDatajintintjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
5082 throw GiwsException::JniMethodNotFoundException(curEnv, "setUiTreeData");
5083 }
5084 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
5085
5086 // create java array of strings.
5087 jobjectArray text_ = curEnv->NewObjectArray( textSize, stringArrayClass, NULL);
5088 if (text_ == NULL)
5089 {
5090 throw GiwsException::JniBadAllocException(curEnv);
5091 }
5092
5093 // convert each char * to java strings and fill the java array.
5094 for ( int i = 0; i < textSize; i++)
5095 {
5096 jstring TempString = curEnv->NewStringUTF( text[i] );
5097 if (TempString == NULL)
5098 {
5099 throw GiwsException::JniBadAllocException(curEnv);
5100 }
5101
5102 curEnv->SetObjectArrayElement( text_, i, TempString);
5103
5104 // avoid keeping reference on to many strings
5105 curEnv->DeleteLocalRef(TempString);
5106 }
5107                          curEnv->CallStaticVoidMethod(cls, voidsetUiTreeDatajintintjobjectArray_java_lang_Stringjava_lang_StringID ,objID, text_);
5108                         curEnv->DeleteLocalRef(stringArrayClass);
5109 curEnv->DeleteLocalRef(text_);
5110 curEnv->DeleteLocalRef(cls);
5111 if (curEnv->ExceptionCheck()) {
5112 throw GiwsException::JniCallMethodException(curEnv);
5113 }
5114 }
5115
5116 }