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