improve management of axes_size and figure_size
[scilab.git] / scilab / modules / graphic_objects / src / jni / Builder.cpp
1 #include "Builder.hxx"
2 /* Generated by GIWS (version 2.0.2) with command:
3 giws --disable-return-size-array --output-dir src\jni\ --throws-exception-on-error --description-file src\jni\builder.giws.xml
4 */
5 /*
6
7 This is generated code.
8
9 This software is a computer program whose purpose is to hide the complexity
10 of accessing Java objects/methods from C++ code.
11
12 This software is governed by the CeCILL-B license under French law and
13 abiding by the rules of distribution of free software.  You can  use,
14 modify and/ or redistribute the software under the terms of the CeCILL-B
15 license as circulated by CEA, CNRS and INRIA at the following URL
16 "http://www.cecill.info".
17
18 As a counterpart to the access to the source code and  rights to copy,
19 modify and redistribute granted by the license, users are provided only
20 with a limited warranty  and the software's author,  the holder of the
21 economic rights,  and the successive licensors  have only  limited
22 liability.
23
24 In this respect, the user's attention is drawn to the risks associated
25 with loading,  using,  modifying and/or developing or reproducing the
26 software by the user in light of its specific status of free software,
27 that may mean  that it is complicated to manipulate,  and  that  also
28 therefore means  that it is reserved for developers  and  experienced
29 professionals having in-depth computer knowledge. Users are therefore
30 encouraged to load and test the software's suitability as regards their
31 requirements in conditions enabling the security of their systems and/or
32 data to be ensured and,  more generally, to use and operate it in the
33 same conditions as regards security.
34
35 The fact that you are presently reading this means that you have had
36 knowledge of the CeCILL-B license and that you accept its terms.
37 */
38
39 namespace org_scilab_modules_graphic_objects_builder {
40
41                 // Static declarations (if any)
42                 
43 // Returns the current env
44
45 JNIEnv * Builder::getCurrentEnv() {
46 JNIEnv * curEnv = NULL;
47 jint res=this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
48 if (res != JNI_OK) {
49 throw GiwsException::JniException(getCurrentEnv());
50 }
51 return curEnv;
52 }
53 // Destructor
54
55 Builder::~Builder() {
56 JNIEnv * curEnv = NULL;
57 this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
58 curEnv->DeleteGlobalRef(this->instance);
59 curEnv->DeleteGlobalRef(this->instanceClass);
60 curEnv->DeleteGlobalRef(this->stringArrayClass);}
61 // Constructors
62 Builder::Builder(JavaVM * jvm_) {
63 jmethodID constructObject = NULL ;
64 jobject localInstance ;
65 jclass localClass ;
66
67 const std::string construct="<init>";
68 const std::string param="()V";
69 jvm=jvm_;
70
71 JNIEnv * curEnv = getCurrentEnv();
72
73 localClass = curEnv->FindClass( this->className().c_str() ) ;
74 if (localClass == NULL) {
75   throw GiwsException::JniClassNotFoundException(curEnv, this->className());
76 }
77
78 this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
79
80 /* localClass is not needed anymore */
81 curEnv->DeleteLocalRef(localClass);
82
83 if (this->instanceClass == NULL) {
84 throw GiwsException::JniObjectCreationException(curEnv, this->className());
85 }
86
87
88 constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
89 if(constructObject == NULL){
90 throw GiwsException::JniObjectCreationException(curEnv, this->className());
91 }
92
93 localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
94 if(localInstance == NULL){
95 throw GiwsException::JniObjectCreationException(curEnv, this->className());
96 }
97  
98 this->instance = curEnv->NewGlobalRef(localInstance) ;
99 if(this->instance == NULL){
100 throw GiwsException::JniObjectCreationException(curEnv, this->className());
101 }
102 /* localInstance not needed anymore */
103 curEnv->DeleteLocalRef(localInstance);
104
105                 /* Methods ID set to NULL */
106 jintcreateRectjintintjdoubledoublejdoubledoublejdoubledoublejdoubledoublejintintjintintjintintjintintID=NULL;
107 jintcloneGraphicContextjintintjintintID=NULL;
108 jintcloneFontContextjintintjintintID=NULL;
109 jintcreateHiddenLabeljintintID=NULL;
110 jbooleanisAxesRedrawingjintintID=NULL;
111 jintcreateLabeljintintjintintID=NULL;
112 jintcreateNewFigureWithAxesID=NULL;
113 jintcreateFigurejbooleanbooleanjintintjintintjbooleanbooleanjbooleanbooleanjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejbooleanbooleanjbooleanbooleanjbooleanbooleanID=NULL;
114 voidcloneMenusjintintjintintID=NULL;
115 jintcloneAxesModeljintintID=NULL;
116 jintcreateSubWinjintintID=NULL;
117 jintcreateTextjintintjobjectArray_java_lang_Stringjava_lang_StringjintintjintintjdoubledoublejdoubledoublejbooleanbooleanjdoubleArray_doubledoublejintintjintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanjintintID=NULL;
118 jintcreateArcjintintjdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanID=NULL;
119 jintcreateAxisjintintjintintjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintjstringjava_lang_StringjintintjintintjintintjbooleanbooleanID=NULL;
120 jintcreateCompoundjintintjintArray_intintID=NULL;
121 jintcreateCompoundSeqjintintjintintID=NULL;
122 jintcreateFecjintintjdoubleArray_doubledoublejintArray_intintjintArray_intintjbooleanbooleanID=NULL;
123 jintcreateGrayplotjintintjintintjdoubleArray_doubledoublejintintjintintID=NULL;
124 jintcreatePolylinejintintjbooleanbooleanjintintjintintjbooleanbooleanjintArray_intintjintintjbooleanbooleanjintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanID=NULL;
125 jintcreateLegendjintintjobjectArray_java_lang_Stringjava_lang_StringjintArray_intintID=NULL;
126 jintcreateSegsjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejbooleanbooleanjintArray_intintjdoubledoubleID=NULL;
127 jintcreateChampjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubledoublejbooleanbooleanID=NULL;
128 jintcreateSurfacejintintjintintjintintjintintID=NULL;
129 voidinitSubWinTo3djintintjstringjava_lang_StringjbooleanbooleanjintArray_intintjdoubledoublejdoubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID=NULL;
130 jintcreateLightjintintjintintjbooleanbooleanjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID=NULL;
131
132
133 }
134
135 Builder::Builder(JavaVM * jvm_, jobject JObj) {
136         jvm=jvm_;
137
138         JNIEnv * curEnv = getCurrentEnv();
139
140 jclass localClass = curEnv->GetObjectClass(JObj);
141         this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
142         curEnv->DeleteLocalRef(localClass);
143
144         if (this->instanceClass == NULL) {
145 throw GiwsException::JniObjectCreationException(curEnv, this->className());
146         }
147
148         this->instance = curEnv->NewGlobalRef(JObj) ;
149         if(this->instance == NULL){
150 throw GiwsException::JniObjectCreationException(curEnv, this->className());
151         }
152         /* Methods ID set to NULL */
153         jintcreateRectjintintjdoubledoublejdoubledoublejdoubledoublejdoubledoublejintintjintintjintintjintintID=NULL;
154 jintcloneGraphicContextjintintjintintID=NULL;
155 jintcloneFontContextjintintjintintID=NULL;
156 jintcreateHiddenLabeljintintID=NULL;
157 jbooleanisAxesRedrawingjintintID=NULL;
158 jintcreateLabeljintintjintintID=NULL;
159 jintcreateNewFigureWithAxesID=NULL;
160 jintcreateFigurejbooleanbooleanjintintjintintjbooleanbooleanjbooleanbooleanjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejbooleanbooleanjbooleanbooleanjbooleanbooleanID=NULL;
161 voidcloneMenusjintintjintintID=NULL;
162 jintcloneAxesModeljintintID=NULL;
163 jintcreateSubWinjintintID=NULL;
164 jintcreateTextjintintjobjectArray_java_lang_Stringjava_lang_StringjintintjintintjdoubledoublejdoubledoublejbooleanbooleanjdoubleArray_doubledoublejintintjintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanjintintID=NULL;
165 jintcreateArcjintintjdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanID=NULL;
166 jintcreateAxisjintintjintintjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintjstringjava_lang_StringjintintjintintjintintjbooleanbooleanID=NULL;
167 jintcreateCompoundjintintjintArray_intintID=NULL;
168 jintcreateCompoundSeqjintintjintintID=NULL;
169 jintcreateFecjintintjdoubleArray_doubledoublejintArray_intintjintArray_intintjbooleanbooleanID=NULL;
170 jintcreateGrayplotjintintjintintjdoubleArray_doubledoublejintintjintintID=NULL;
171 jintcreatePolylinejintintjbooleanbooleanjintintjintintjbooleanbooleanjintArray_intintjintintjbooleanbooleanjintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanID=NULL;
172 jintcreateLegendjintintjobjectArray_java_lang_Stringjava_lang_StringjintArray_intintID=NULL;
173 jintcreateSegsjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejbooleanbooleanjintArray_intintjdoubledoubleID=NULL;
174 jintcreateChampjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubledoublejbooleanbooleanID=NULL;
175 jintcreateSurfacejintintjintintjintintjintintID=NULL;
176 voidinitSubWinTo3djintintjstringjava_lang_StringjbooleanbooleanjintArray_intintjdoubledoublejdoubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID=NULL;
177 jintcreateLightjintintjintintjbooleanbooleanjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID=NULL;
178
179
180 }
181
182 // Generic methods
183
184 void Builder::synchronize() {
185 if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
186 throw GiwsException::JniMonitorException(getCurrentEnv(), "Builder");
187 }
188 }
189
190 void Builder::endSynchronize() {
191 if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
192 throw GiwsException::JniMonitorException(getCurrentEnv(), "Builder");
193 }
194 }
195 // Method(s)
196
197 int Builder::createRect (JavaVM * jvm_, int pparentsubwinUID, double x, double y, double height, double width, int foreground, int background, int isfilled, int isline){
198
199 JNIEnv * curEnv = NULL;
200 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
201 jclass cls = initClass(curEnv);
202 if ( cls == NULL) {
203 throw GiwsException::JniCallMethodException(curEnv);
204 }
205
206 static jmethodID jintcreateRectjintintjdoubledoublejdoubledoublejdoubledoublejdoubledoublejintintjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "createRect", "(IDDDDIIII)I" ) ;
207 if (jintcreateRectjintintjdoubledoublejdoubledoublejdoubledoublejdoubledoublejintintjintintjintintjintintID == NULL) {
208 throw GiwsException::JniMethodNotFoundException(curEnv, "createRect");
209 }
210
211                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateRectjintintjdoubledoublejdoubledoublejdoubledoublejdoubledoublejintintjintintjintintjintintID ,pparentsubwinUID, x, y, height, width, foreground, background, isfilled, isline));
212                         if (curEnv->ExceptionCheck()) {
213 throw GiwsException::JniCallMethodException(curEnv);
214 }
215 return res;
216
217 }
218
219 int Builder::cloneGraphicContext (JavaVM * jvm_, int sourceIdentifier, int destIdentifier){
220
221 JNIEnv * curEnv = NULL;
222 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
223 jclass cls = initClass(curEnv);
224 if ( cls == NULL) {
225 throw GiwsException::JniCallMethodException(curEnv);
226 }
227
228 static jmethodID jintcloneGraphicContextjintintjintintID = curEnv->GetStaticMethodID(cls, "cloneGraphicContext", "(II)I" ) ;
229 if (jintcloneGraphicContextjintintjintintID == NULL) {
230 throw GiwsException::JniMethodNotFoundException(curEnv, "cloneGraphicContext");
231 }
232
233                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcloneGraphicContextjintintjintintID ,sourceIdentifier, destIdentifier));
234                         if (curEnv->ExceptionCheck()) {
235 throw GiwsException::JniCallMethodException(curEnv);
236 }
237 return res;
238
239 }
240
241 int Builder::cloneFontContext (JavaVM * jvm_, int sourceIdentifier, int destIdentifier){
242
243 JNIEnv * curEnv = NULL;
244 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
245 jclass cls = initClass(curEnv);
246 if ( cls == NULL) {
247 throw GiwsException::JniCallMethodException(curEnv);
248 }
249
250 static jmethodID jintcloneFontContextjintintjintintID = curEnv->GetStaticMethodID(cls, "cloneFontContext", "(II)I" ) ;
251 if (jintcloneFontContextjintintjintintID == NULL) {
252 throw GiwsException::JniMethodNotFoundException(curEnv, "cloneFontContext");
253 }
254
255                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcloneFontContextjintintjintintID ,sourceIdentifier, destIdentifier));
256                         if (curEnv->ExceptionCheck()) {
257 throw GiwsException::JniCallMethodException(curEnv);
258 }
259 return res;
260
261 }
262
263 int Builder::createHiddenLabel (JavaVM * jvm_, int parent){
264
265 JNIEnv * curEnv = NULL;
266 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
267 jclass cls = initClass(curEnv);
268 if ( cls == NULL) {
269 throw GiwsException::JniCallMethodException(curEnv);
270 }
271
272 static jmethodID jintcreateHiddenLabeljintintID = curEnv->GetStaticMethodID(cls, "createHiddenLabel", "(I)I" ) ;
273 if (jintcreateHiddenLabeljintintID == NULL) {
274 throw GiwsException::JniMethodNotFoundException(curEnv, "createHiddenLabel");
275 }
276
277                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateHiddenLabeljintintID ,parent));
278                         if (curEnv->ExceptionCheck()) {
279 throw GiwsException::JniCallMethodException(curEnv);
280 }
281 return res;
282
283 }
284
285 bool Builder::isAxesRedrawing (JavaVM * jvm_, int subWin){
286
287 JNIEnv * curEnv = NULL;
288 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
289 jclass cls = initClass(curEnv);
290 if ( cls == NULL) {
291 throw GiwsException::JniCallMethodException(curEnv);
292 }
293
294 static jmethodID jbooleanisAxesRedrawingjintintID = curEnv->GetStaticMethodID(cls, "isAxesRedrawing", "(I)Z" ) ;
295 if (jbooleanisAxesRedrawingjintintID == NULL) {
296 throw GiwsException::JniMethodNotFoundException(curEnv, "isAxesRedrawing");
297 }
298
299                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanisAxesRedrawingjintintID ,subWin));
300                         if (curEnv->ExceptionCheck()) {
301 throw GiwsException::JniCallMethodException(curEnv);
302 }
303 return (res == JNI_TRUE);
304
305 }
306
307 int Builder::createLabel (JavaVM * jvm_, int parent, int type){
308
309 JNIEnv * curEnv = NULL;
310 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
311 jclass cls = initClass(curEnv);
312 if ( cls == NULL) {
313 throw GiwsException::JniCallMethodException(curEnv);
314 }
315
316 static jmethodID jintcreateLabeljintintjintintID = curEnv->GetStaticMethodID(cls, "createLabel", "(II)I" ) ;
317 if (jintcreateLabeljintintjintintID == NULL) {
318 throw GiwsException::JniMethodNotFoundException(curEnv, "createLabel");
319 }
320
321                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateLabeljintintjintintID ,parent, type));
322                         if (curEnv->ExceptionCheck()) {
323 throw GiwsException::JniCallMethodException(curEnv);
324 }
325 return res;
326
327 }
328
329 int Builder::createNewFigureWithAxes (JavaVM * jvm_){
330
331 JNIEnv * curEnv = NULL;
332 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
333 jclass cls = initClass(curEnv);
334 if ( cls == NULL) {
335 throw GiwsException::JniCallMethodException(curEnv);
336 }
337
338 static jmethodID jintcreateNewFigureWithAxesID = curEnv->GetStaticMethodID(cls, "createNewFigureWithAxes", "()I" ) ;
339 if (jintcreateNewFigureWithAxesID == NULL) {
340 throw GiwsException::JniMethodNotFoundException(curEnv, "createNewFigureWithAxes");
341 }
342
343                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateNewFigureWithAxesID ));
344                         if (curEnv->ExceptionCheck()) {
345 throw GiwsException::JniCallMethodException(curEnv);
346 }
347 return res;
348
349 }
350
351 int Builder::createFigure (JavaVM * jvm_, bool dockable, int menubarType, int toolbarType, bool defaultAxes, bool visible, double const* figureSize, int figureSizeSize, double const* axesSize, int axesSizeSize, double const* position, int positionSize, bool menubar, bool toolbar, bool infobar){
352
353 JNIEnv * curEnv = NULL;
354 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
355 jclass cls = initClass(curEnv);
356 if ( cls == NULL) {
357 throw GiwsException::JniCallMethodException(curEnv);
358 }
359
360 static jmethodID jintcreateFigurejbooleanbooleanjintintjintintjbooleanbooleanjbooleanbooleanjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejbooleanbooleanjbooleanbooleanjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "createFigure", "(ZIIZZ[D[D[DZZZ)I" ) ;
361 if (jintcreateFigurejbooleanbooleanjintintjintintjbooleanbooleanjbooleanbooleanjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejbooleanbooleanjbooleanbooleanjbooleanbooleanID == NULL) {
362 throw GiwsException::JniMethodNotFoundException(curEnv, "createFigure");
363 }
364
365 jboolean dockable_ = (static_cast<bool>(dockable) ? JNI_TRUE : JNI_FALSE);
366
367 jboolean defaultAxes_ = (static_cast<bool>(defaultAxes) ? JNI_TRUE : JNI_FALSE);
368
369 jboolean visible_ = (static_cast<bool>(visible) ? JNI_TRUE : JNI_FALSE);
370
371 jdoubleArray figureSize_ = curEnv->NewDoubleArray( figureSizeSize ) ;
372
373 if (figureSize_ == NULL)
374 {
375 // check that allocation succeed
376 throw GiwsException::JniBadAllocException(curEnv);
377 }
378
379 curEnv->SetDoubleArrayRegion( figureSize_, 0, figureSizeSize, (jdouble*)(figureSize) ) ;
380
381
382 jdoubleArray axesSize_ = curEnv->NewDoubleArray( axesSizeSize ) ;
383
384 if (axesSize_ == NULL)
385 {
386 // check that allocation succeed
387 throw GiwsException::JniBadAllocException(curEnv);
388 }
389
390 curEnv->SetDoubleArrayRegion( axesSize_, 0, axesSizeSize, (jdouble*)(axesSize) ) ;
391
392
393 jdoubleArray position_ = curEnv->NewDoubleArray( positionSize ) ;
394
395 if (position_ == NULL)
396 {
397 // check that allocation succeed
398 throw GiwsException::JniBadAllocException(curEnv);
399 }
400
401 curEnv->SetDoubleArrayRegion( position_, 0, positionSize, (jdouble*)(position) ) ;
402
403
404 jboolean menubar_ = (static_cast<bool>(menubar) ? JNI_TRUE : JNI_FALSE);
405
406 jboolean toolbar_ = (static_cast<bool>(toolbar) ? JNI_TRUE : JNI_FALSE);
407
408 jboolean infobar_ = (static_cast<bool>(infobar) ? JNI_TRUE : JNI_FALSE);
409
410                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateFigurejbooleanbooleanjintintjintintjbooleanbooleanjbooleanbooleanjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejbooleanbooleanjbooleanbooleanjbooleanbooleanID ,dockable_, menubarType, toolbarType, defaultAxes_, visible_, figureSize_, axesSize_, position_, menubar_, toolbar_, infobar_));
411                         curEnv->DeleteLocalRef(figureSize_);
412 curEnv->DeleteLocalRef(axesSize_);
413 curEnv->DeleteLocalRef(position_);
414 if (curEnv->ExceptionCheck()) {
415 throw GiwsException::JniCallMethodException(curEnv);
416 }
417 return res;
418
419 }
420
421 void Builder::cloneMenus (JavaVM * jvm_, int model, int newParent){
422
423 JNIEnv * curEnv = NULL;
424 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
425 jclass cls = initClass(curEnv);
426 if ( cls == NULL) {
427 throw GiwsException::JniCallMethodException(curEnv);
428 }
429
430 static jmethodID voidcloneMenusjintintjintintID = curEnv->GetStaticMethodID(cls, "cloneMenus", "(II)V" ) ;
431 if (voidcloneMenusjintintjintintID == NULL) {
432 throw GiwsException::JniMethodNotFoundException(curEnv, "cloneMenus");
433 }
434
435                          curEnv->CallStaticVoidMethod(cls, voidcloneMenusjintintjintintID ,model, newParent);
436                         if (curEnv->ExceptionCheck()) {
437 throw GiwsException::JniCallMethodException(curEnv);
438 }
439 }
440
441 int Builder::cloneAxesModel (JavaVM * jvm_, int parent){
442
443 JNIEnv * curEnv = NULL;
444 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
445 jclass cls = initClass(curEnv);
446 if ( cls == NULL) {
447 throw GiwsException::JniCallMethodException(curEnv);
448 }
449
450 static jmethodID jintcloneAxesModeljintintID = curEnv->GetStaticMethodID(cls, "cloneAxesModel", "(I)I" ) ;
451 if (jintcloneAxesModeljintintID == NULL) {
452 throw GiwsException::JniMethodNotFoundException(curEnv, "cloneAxesModel");
453 }
454
455                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcloneAxesModeljintintID ,parent));
456                         if (curEnv->ExceptionCheck()) {
457 throw GiwsException::JniCallMethodException(curEnv);
458 }
459 return res;
460
461 }
462
463 int Builder::createSubWin (JavaVM * jvm_, int parent){
464
465 JNIEnv * curEnv = NULL;
466 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
467 jclass cls = initClass(curEnv);
468 if ( cls == NULL) {
469 throw GiwsException::JniCallMethodException(curEnv);
470 }
471
472 static jmethodID jintcreateSubWinjintintID = curEnv->GetStaticMethodID(cls, "createSubWin", "(I)I" ) ;
473 if (jintcreateSubWinjintintID == NULL) {
474 throw GiwsException::JniMethodNotFoundException(curEnv, "createSubWin");
475 }
476
477                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateSubWinjintintID ,parent));
478                         if (curEnv->ExceptionCheck()) {
479 throw GiwsException::JniCallMethodException(curEnv);
480 }
481 return res;
482
483 }
484
485 int Builder::createText (JavaVM * jvm_, int parent, char const* const* text, int textSize, int rows, int cols, double x, double y, bool autoSize, double const* userSize, int userSizeSize, int centerPos, int foreground, bool isForeground, int background, bool isBackground, bool boxed, bool line, bool filled, int align){
486
487 JNIEnv * curEnv = NULL;
488 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
489 jclass cls = initClass(curEnv);
490 if ( cls == NULL) {
491 throw GiwsException::JniCallMethodException(curEnv);
492 }
493
494 static jmethodID jintcreateTextjintintjobjectArray_java_lang_Stringjava_lang_StringjintintjintintjdoubledoublejdoubledoublejbooleanbooleanjdoubleArray_doubledoublejintintjintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "createText", "(I[Ljava/lang/String;IIDDZ[DIIZIZZZZI)I" ) ;
495 if (jintcreateTextjintintjobjectArray_java_lang_Stringjava_lang_StringjintintjintintjdoubledoublejdoubledoublejbooleanbooleanjdoubleArray_doubledoublejintintjintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanjintintID == NULL) {
496 throw GiwsException::JniMethodNotFoundException(curEnv, "createText");
497 }
498 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
499
500 // create java array of strings.
501 jobjectArray text_ = curEnv->NewObjectArray( textSize, stringArrayClass, NULL);
502 if (text_ == NULL)
503 {
504 throw GiwsException::JniBadAllocException(curEnv);
505 }
506
507 // convert each char * to java strings and fill the java array.
508 for ( int i = 0; i < textSize; i++)
509 {
510 jstring TempString = curEnv->NewStringUTF( text[i] );
511 if (TempString == NULL)
512 {
513 throw GiwsException::JniBadAllocException(curEnv);
514 }
515
516 curEnv->SetObjectArrayElement( text_, i, TempString);
517
518 // avoid keeping reference on too many strings
519 curEnv->DeleteLocalRef(TempString);
520 }
521 jboolean autoSize_ = (static_cast<bool>(autoSize) ? JNI_TRUE : JNI_FALSE);
522
523 jdoubleArray userSize_ = curEnv->NewDoubleArray( userSizeSize ) ;
524
525 if (userSize_ == NULL)
526 {
527 // check that allocation succeed
528 throw GiwsException::JniBadAllocException(curEnv);
529 }
530
531 curEnv->SetDoubleArrayRegion( userSize_, 0, userSizeSize, (jdouble*)(userSize) ) ;
532
533
534 jboolean isForeground_ = (static_cast<bool>(isForeground) ? JNI_TRUE : JNI_FALSE);
535
536 jboolean isBackground_ = (static_cast<bool>(isBackground) ? JNI_TRUE : JNI_FALSE);
537
538 jboolean boxed_ = (static_cast<bool>(boxed) ? JNI_TRUE : JNI_FALSE);
539
540 jboolean line_ = (static_cast<bool>(line) ? JNI_TRUE : JNI_FALSE);
541
542 jboolean filled_ = (static_cast<bool>(filled) ? JNI_TRUE : JNI_FALSE);
543
544                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateTextjintintjobjectArray_java_lang_Stringjava_lang_StringjintintjintintjdoubledoublejdoubledoublejbooleanbooleanjdoubleArray_doubledoublejintintjintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanjintintID ,parent, text_, rows, cols, x, y, autoSize_, userSize_, centerPos, foreground, isForeground_, background, isBackground_, boxed_, line_, filled_, align));
545                         curEnv->DeleteLocalRef(stringArrayClass);
546 curEnv->DeleteLocalRef(text_);
547 curEnv->DeleteLocalRef(userSize_);
548 if (curEnv->ExceptionCheck()) {
549 throw GiwsException::JniCallMethodException(curEnv);
550 }
551 return res;
552
553 }
554
555 int Builder::createArc (JavaVM * jvm_, int parent, double x, double y, double h, double w, double start, double end, int foreground, bool isForeground, int background, bool isBackground, bool filled, bool line){
556
557 JNIEnv * curEnv = NULL;
558 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
559 jclass cls = initClass(curEnv);
560 if ( cls == NULL) {
561 throw GiwsException::JniCallMethodException(curEnv);
562 }
563
564 static jmethodID jintcreateArcjintintjdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "createArc", "(IDDDDDDIZIZZZ)I" ) ;
565 if (jintcreateArcjintintjdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanID == NULL) {
566 throw GiwsException::JniMethodNotFoundException(curEnv, "createArc");
567 }
568
569 jboolean isForeground_ = (static_cast<bool>(isForeground) ? JNI_TRUE : JNI_FALSE);
570
571 jboolean isBackground_ = (static_cast<bool>(isBackground) ? JNI_TRUE : JNI_FALSE);
572
573 jboolean filled_ = (static_cast<bool>(filled) ? JNI_TRUE : JNI_FALSE);
574
575 jboolean line_ = (static_cast<bool>(line) ? JNI_TRUE : JNI_FALSE);
576
577                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateArcjintintjdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanID ,parent, x, y, h, w, start, end, foreground, isForeground_, background, isBackground_, filled_, line_));
578                         if (curEnv->ExceptionCheck()) {
579 throw GiwsException::JniCallMethodException(curEnv);
580 }
581 return res;
582
583 }
584
585 int Builder::createAxis (JavaVM * jvm_, int parent, int dir, int tics, double const* vx, int vxSize, double const* vy, int vySize, int subint, char const* format, int fontSize, int textColor, int ticsColor, bool seg){
586
587 JNIEnv * curEnv = NULL;
588 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
589 jclass cls = initClass(curEnv);
590 if ( cls == NULL) {
591 throw GiwsException::JniCallMethodException(curEnv);
592 }
593
594 static jmethodID jintcreateAxisjintintjintintjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintjstringjava_lang_StringjintintjintintjintintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "createAxis", "(III[D[DILjava/lang/String;IIIZ)I" ) ;
595 if (jintcreateAxisjintintjintintjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintjstringjava_lang_StringjintintjintintjintintjbooleanbooleanID == NULL) {
596 throw GiwsException::JniMethodNotFoundException(curEnv, "createAxis");
597 }
598
599 jdoubleArray vx_ = curEnv->NewDoubleArray( vxSize ) ;
600
601 if (vx_ == NULL)
602 {
603 // check that allocation succeed
604 throw GiwsException::JniBadAllocException(curEnv);
605 }
606
607 curEnv->SetDoubleArrayRegion( vx_, 0, vxSize, (jdouble*)(vx) ) ;
608
609
610 jdoubleArray vy_ = curEnv->NewDoubleArray( vySize ) ;
611
612 if (vy_ == NULL)
613 {
614 // check that allocation succeed
615 throw GiwsException::JniBadAllocException(curEnv);
616 }
617
618 curEnv->SetDoubleArrayRegion( vy_, 0, vySize, (jdouble*)(vy) ) ;
619
620
621 jstring format_ = curEnv->NewStringUTF( format );
622 if (format != NULL && format_ == NULL)
623 {
624 throw GiwsException::JniBadAllocException(curEnv);
625 }
626
627
628 jboolean seg_ = (static_cast<bool>(seg) ? JNI_TRUE : JNI_FALSE);
629
630                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateAxisjintintjintintjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintjstringjava_lang_StringjintintjintintjintintjbooleanbooleanID ,parent, dir, tics, vx_, vy_, subint, format_, fontSize, textColor, ticsColor, seg_));
631                         curEnv->DeleteLocalRef(vx_);
632 curEnv->DeleteLocalRef(vy_);
633 curEnv->DeleteLocalRef(format_);
634 if (curEnv->ExceptionCheck()) {
635 throw GiwsException::JniCallMethodException(curEnv);
636 }
637 return res;
638
639 }
640
641 int Builder::createCompound (JavaVM * jvm_, int parent, int const* children, int childrenSize){
642
643 JNIEnv * curEnv = NULL;
644 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
645 jclass cls = initClass(curEnv);
646 if ( cls == NULL) {
647 throw GiwsException::JniCallMethodException(curEnv);
648 }
649
650 static jmethodID jintcreateCompoundjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "createCompound", "(I[I)I" ) ;
651 if (jintcreateCompoundjintintjintArray_intintID == NULL) {
652 throw GiwsException::JniMethodNotFoundException(curEnv, "createCompound");
653 }
654
655 jintArray children_ = curEnv->NewIntArray( childrenSize ) ;
656
657 if (children_ == NULL)
658 {
659 // check that allocation succeed
660 throw GiwsException::JniBadAllocException(curEnv);
661 }
662
663 curEnv->SetIntArrayRegion( children_, 0, childrenSize, (jint*)(children) ) ;
664
665
666                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateCompoundjintintjintArray_intintID ,parent, children_));
667                         curEnv->DeleteLocalRef(children_);
668 if (curEnv->ExceptionCheck()) {
669 throw GiwsException::JniCallMethodException(curEnv);
670 }
671 return res;
672
673 }
674
675 int Builder::createCompoundSeq (JavaVM * jvm_, int parent, int childrenCount){
676
677 JNIEnv * curEnv = NULL;
678 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
679 jclass cls = initClass(curEnv);
680 if ( cls == NULL) {
681 throw GiwsException::JniCallMethodException(curEnv);
682 }
683
684 static jmethodID jintcreateCompoundSeqjintintjintintID = curEnv->GetStaticMethodID(cls, "createCompoundSeq", "(II)I" ) ;
685 if (jintcreateCompoundSeqjintintjintintID == NULL) {
686 throw GiwsException::JniMethodNotFoundException(curEnv, "createCompoundSeq");
687 }
688
689                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateCompoundSeqjintintjintintID ,parent, childrenCount));
690                         if (curEnv->ExceptionCheck()) {
691 throw GiwsException::JniCallMethodException(curEnv);
692 }
693 return res;
694
695 }
696
697 int Builder::createFec (JavaVM * jvm_, int parent, double const* zminmax, int zminmaxSize, int const* colminmax, int colminmaxSize, int const* colout, int coloutSize, bool with_mesh){
698
699 JNIEnv * curEnv = NULL;
700 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
701 jclass cls = initClass(curEnv);
702 if ( cls == NULL) {
703 throw GiwsException::JniCallMethodException(curEnv);
704 }
705
706 static jmethodID jintcreateFecjintintjdoubleArray_doubledoublejintArray_intintjintArray_intintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "createFec", "(I[D[I[IZ)I" ) ;
707 if (jintcreateFecjintintjdoubleArray_doubledoublejintArray_intintjintArray_intintjbooleanbooleanID == NULL) {
708 throw GiwsException::JniMethodNotFoundException(curEnv, "createFec");
709 }
710
711 jdoubleArray zminmax_ = curEnv->NewDoubleArray( zminmaxSize ) ;
712
713 if (zminmax_ == NULL)
714 {
715 // check that allocation succeed
716 throw GiwsException::JniBadAllocException(curEnv);
717 }
718
719 curEnv->SetDoubleArrayRegion( zminmax_, 0, zminmaxSize, (jdouble*)(zminmax) ) ;
720
721
722 jintArray colminmax_ = curEnv->NewIntArray( colminmaxSize ) ;
723
724 if (colminmax_ == NULL)
725 {
726 // check that allocation succeed
727 throw GiwsException::JniBadAllocException(curEnv);
728 }
729
730 curEnv->SetIntArrayRegion( colminmax_, 0, colminmaxSize, (jint*)(colminmax) ) ;
731
732
733 jintArray colout_ = curEnv->NewIntArray( coloutSize ) ;
734
735 if (colout_ == NULL)
736 {
737 // check that allocation succeed
738 throw GiwsException::JniBadAllocException(curEnv);
739 }
740
741 curEnv->SetIntArrayRegion( colout_, 0, coloutSize, (jint*)(colout) ) ;
742
743
744 jboolean with_mesh_ = (static_cast<bool>(with_mesh) ? JNI_TRUE : JNI_FALSE);
745
746                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateFecjintintjdoubleArray_doubledoublejintArray_intintjintArray_intintjbooleanbooleanID ,parent, zminmax_, colminmax_, colout_, with_mesh_));
747                         curEnv->DeleteLocalRef(zminmax_);
748 curEnv->DeleteLocalRef(colminmax_);
749 curEnv->DeleteLocalRef(colout_);
750 if (curEnv->ExceptionCheck()) {
751 throw GiwsException::JniCallMethodException(curEnv);
752 }
753 return res;
754
755 }
756
757 int Builder::createGrayplot (JavaVM * jvm_, int parent, int type, double const* pvecx, int pvecxSize, int n1, int n2){
758
759 JNIEnv * curEnv = NULL;
760 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
761 jclass cls = initClass(curEnv);
762 if ( cls == NULL) {
763 throw GiwsException::JniCallMethodException(curEnv);
764 }
765
766 static jmethodID jintcreateGrayplotjintintjintintjdoubleArray_doubledoublejintintjintintID = curEnv->GetStaticMethodID(cls, "createGrayplot", "(II[DII)I" ) ;
767 if (jintcreateGrayplotjintintjintintjdoubleArray_doubledoublejintintjintintID == NULL) {
768 throw GiwsException::JniMethodNotFoundException(curEnv, "createGrayplot");
769 }
770
771 jdoubleArray pvecx_ = curEnv->NewDoubleArray( pvecxSize ) ;
772
773 if (pvecx_ == NULL)
774 {
775 // check that allocation succeed
776 throw GiwsException::JniBadAllocException(curEnv);
777 }
778
779 curEnv->SetDoubleArrayRegion( pvecx_, 0, pvecxSize, (jdouble*)(pvecx) ) ;
780
781
782                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateGrayplotjintintjintintjdoubleArray_doubledoublejintintjintintID ,parent, type, pvecx_, n1, n2));
783                         curEnv->DeleteLocalRef(pvecx_);
784 if (curEnv->ExceptionCheck()) {
785 throw GiwsException::JniCallMethodException(curEnv);
786 }
787 return res;
788
789 }
790
791 int Builder::createPolyline (JavaVM * jvm_, int parent, bool closed, int plot, int foreground, bool isForeground, int const* background, int backgroundSize, int mark_style, bool isMarkStyle, int mark_foreground, bool isMarkForeground, int mark_background, bool isMarkBackground, bool isline, bool isfilled, bool ismark, bool isinterp){
792
793 JNIEnv * curEnv = NULL;
794 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
795 jclass cls = initClass(curEnv);
796 if ( cls == NULL) {
797 throw GiwsException::JniCallMethodException(curEnv);
798 }
799
800 static jmethodID jintcreatePolylinejintintjbooleanbooleanjintintjintintjbooleanbooleanjintArray_intintjintintjbooleanbooleanjintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "createPolyline", "(IZIIZ[IIZIZIZZZZZ)I" ) ;
801 if (jintcreatePolylinejintintjbooleanbooleanjintintjintintjbooleanbooleanjintArray_intintjintintjbooleanbooleanjintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanID == NULL) {
802 throw GiwsException::JniMethodNotFoundException(curEnv, "createPolyline");
803 }
804
805 jboolean closed_ = (static_cast<bool>(closed) ? JNI_TRUE : JNI_FALSE);
806
807 jboolean isForeground_ = (static_cast<bool>(isForeground) ? JNI_TRUE : JNI_FALSE);
808
809 jintArray background_ = curEnv->NewIntArray( backgroundSize ) ;
810
811 if (background_ == NULL)
812 {
813 // check that allocation succeed
814 throw GiwsException::JniBadAllocException(curEnv);
815 }
816
817 curEnv->SetIntArrayRegion( background_, 0, backgroundSize, (jint*)(background) ) ;
818
819
820 jboolean isMarkStyle_ = (static_cast<bool>(isMarkStyle) ? JNI_TRUE : JNI_FALSE);
821
822 jboolean isMarkForeground_ = (static_cast<bool>(isMarkForeground) ? JNI_TRUE : JNI_FALSE);
823
824 jboolean isMarkBackground_ = (static_cast<bool>(isMarkBackground) ? JNI_TRUE : JNI_FALSE);
825
826 jboolean isline_ = (static_cast<bool>(isline) ? JNI_TRUE : JNI_FALSE);
827
828 jboolean isfilled_ = (static_cast<bool>(isfilled) ? JNI_TRUE : JNI_FALSE);
829
830 jboolean ismark_ = (static_cast<bool>(ismark) ? JNI_TRUE : JNI_FALSE);
831
832 jboolean isinterp_ = (static_cast<bool>(isinterp) ? JNI_TRUE : JNI_FALSE);
833
834                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreatePolylinejintintjbooleanbooleanjintintjintintjbooleanbooleanjintArray_intintjintintjbooleanbooleanjintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanID ,parent, closed_, plot, foreground, isForeground_, background_, mark_style, isMarkStyle_, mark_foreground, isMarkForeground_, mark_background, isMarkBackground_, isline_, isfilled_, ismark_, isinterp_));
835                         curEnv->DeleteLocalRef(background_);
836 if (curEnv->ExceptionCheck()) {
837 throw GiwsException::JniCallMethodException(curEnv);
838 }
839 return res;
840
841 }
842
843 int Builder::createLegend (JavaVM * jvm_, int parent, char const* const* text, int textSize, int const* handles, int handlesSize){
844
845 JNIEnv * curEnv = NULL;
846 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
847 jclass cls = initClass(curEnv);
848 if ( cls == NULL) {
849 throw GiwsException::JniCallMethodException(curEnv);
850 }
851
852 static jmethodID jintcreateLegendjintintjobjectArray_java_lang_Stringjava_lang_StringjintArray_intintID = curEnv->GetStaticMethodID(cls, "createLegend", "(I[Ljava/lang/String;[I)I" ) ;
853 if (jintcreateLegendjintintjobjectArray_java_lang_Stringjava_lang_StringjintArray_intintID == NULL) {
854 throw GiwsException::JniMethodNotFoundException(curEnv, "createLegend");
855 }
856 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
857
858 // create java array of strings.
859 jobjectArray text_ = curEnv->NewObjectArray( textSize, stringArrayClass, NULL);
860 if (text_ == NULL)
861 {
862 throw GiwsException::JniBadAllocException(curEnv);
863 }
864
865 // convert each char * to java strings and fill the java array.
866 for ( int i = 0; i < textSize; i++)
867 {
868 jstring TempString = curEnv->NewStringUTF( text[i] );
869 if (TempString == NULL)
870 {
871 throw GiwsException::JniBadAllocException(curEnv);
872 }
873
874 curEnv->SetObjectArrayElement( text_, i, TempString);
875
876 // avoid keeping reference on too many strings
877 curEnv->DeleteLocalRef(TempString);
878 }
879 jintArray handles_ = curEnv->NewIntArray( handlesSize ) ;
880
881 if (handles_ == NULL)
882 {
883 // check that allocation succeed
884 throw GiwsException::JniBadAllocException(curEnv);
885 }
886
887 curEnv->SetIntArrayRegion( handles_, 0, handlesSize, (jint*)(handles) ) ;
888
889
890                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateLegendjintintjobjectArray_java_lang_Stringjava_lang_StringjintArray_intintID ,parent, text_, handles_));
891                         curEnv->DeleteLocalRef(stringArrayClass);
892 curEnv->DeleteLocalRef(text_);
893 curEnv->DeleteLocalRef(handles_);
894 if (curEnv->ExceptionCheck()) {
895 throw GiwsException::JniCallMethodException(curEnv);
896 }
897 return res;
898
899 }
900
901 int Builder::createSegs (JavaVM * jvm_, int parent, double const* vx, int vxSize, double const* vy, int vySize, double const* vz, int vzSize, bool isVZ, int const* style, int styleSize, double arsize){
902
903 JNIEnv * curEnv = NULL;
904 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
905 jclass cls = initClass(curEnv);
906 if ( cls == NULL) {
907 throw GiwsException::JniCallMethodException(curEnv);
908 }
909
910 static jmethodID jintcreateSegsjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejbooleanbooleanjintArray_intintjdoubledoubleID = curEnv->GetStaticMethodID(cls, "createSegs", "(I[D[D[DZ[ID)I" ) ;
911 if (jintcreateSegsjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejbooleanbooleanjintArray_intintjdoubledoubleID == NULL) {
912 throw GiwsException::JniMethodNotFoundException(curEnv, "createSegs");
913 }
914
915 jdoubleArray vx_ = curEnv->NewDoubleArray( vxSize ) ;
916
917 if (vx_ == NULL)
918 {
919 // check that allocation succeed
920 throw GiwsException::JniBadAllocException(curEnv);
921 }
922
923 curEnv->SetDoubleArrayRegion( vx_, 0, vxSize, (jdouble*)(vx) ) ;
924
925
926 jdoubleArray vy_ = curEnv->NewDoubleArray( vySize ) ;
927
928 if (vy_ == NULL)
929 {
930 // check that allocation succeed
931 throw GiwsException::JniBadAllocException(curEnv);
932 }
933
934 curEnv->SetDoubleArrayRegion( vy_, 0, vySize, (jdouble*)(vy) ) ;
935
936
937 jdoubleArray vz_ = curEnv->NewDoubleArray( vzSize ) ;
938
939 if (vz_ == NULL)
940 {
941 // check that allocation succeed
942 throw GiwsException::JniBadAllocException(curEnv);
943 }
944
945 curEnv->SetDoubleArrayRegion( vz_, 0, vzSize, (jdouble*)(vz) ) ;
946
947
948 jboolean isVZ_ = (static_cast<bool>(isVZ) ? JNI_TRUE : JNI_FALSE);
949
950 jintArray style_ = curEnv->NewIntArray( styleSize ) ;
951
952 if (style_ == NULL)
953 {
954 // check that allocation succeed
955 throw GiwsException::JniBadAllocException(curEnv);
956 }
957
958 curEnv->SetIntArrayRegion( style_, 0, styleSize, (jint*)(style) ) ;
959
960
961                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateSegsjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejbooleanbooleanjintArray_intintjdoubledoubleID ,parent, vx_, vy_, vz_, isVZ_, style_, arsize));
962                         curEnv->DeleteLocalRef(vx_);
963 curEnv->DeleteLocalRef(vy_);
964 curEnv->DeleteLocalRef(vz_);
965 curEnv->DeleteLocalRef(style_);
966 if (curEnv->ExceptionCheck()) {
967 throw GiwsException::JniCallMethodException(curEnv);
968 }
969 return res;
970
971 }
972
973 int Builder::createChamp (JavaVM * jvm_, int parent, double const* vx, int vxSize, double const* vy, int vySize, double const* vfx, int vfxSize, double const* vfy, int vfySize, double arsize, bool typeofchamp){
974
975 JNIEnv * curEnv = NULL;
976 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
977 jclass cls = initClass(curEnv);
978 if ( cls == NULL) {
979 throw GiwsException::JniCallMethodException(curEnv);
980 }
981
982 static jmethodID jintcreateChampjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubledoublejbooleanbooleanID = curEnv->GetStaticMethodID(cls, "createChamp", "(I[D[D[D[DDZ)I" ) ;
983 if (jintcreateChampjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubledoublejbooleanbooleanID == NULL) {
984 throw GiwsException::JniMethodNotFoundException(curEnv, "createChamp");
985 }
986
987 jdoubleArray vx_ = curEnv->NewDoubleArray( vxSize ) ;
988
989 if (vx_ == NULL)
990 {
991 // check that allocation succeed
992 throw GiwsException::JniBadAllocException(curEnv);
993 }
994
995 curEnv->SetDoubleArrayRegion( vx_, 0, vxSize, (jdouble*)(vx) ) ;
996
997
998 jdoubleArray vy_ = curEnv->NewDoubleArray( vySize ) ;
999
1000 if (vy_ == NULL)
1001 {
1002 // check that allocation succeed
1003 throw GiwsException::JniBadAllocException(curEnv);
1004 }
1005
1006 curEnv->SetDoubleArrayRegion( vy_, 0, vySize, (jdouble*)(vy) ) ;
1007
1008
1009 jdoubleArray vfx_ = curEnv->NewDoubleArray( vfxSize ) ;
1010
1011 if (vfx_ == NULL)
1012 {
1013 // check that allocation succeed
1014 throw GiwsException::JniBadAllocException(curEnv);
1015 }
1016
1017 curEnv->SetDoubleArrayRegion( vfx_, 0, vfxSize, (jdouble*)(vfx) ) ;
1018
1019
1020 jdoubleArray vfy_ = curEnv->NewDoubleArray( vfySize ) ;
1021
1022 if (vfy_ == NULL)
1023 {
1024 // check that allocation succeed
1025 throw GiwsException::JniBadAllocException(curEnv);
1026 }
1027
1028 curEnv->SetDoubleArrayRegion( vfy_, 0, vfySize, (jdouble*)(vfy) ) ;
1029
1030
1031 jboolean typeofchamp_ = (static_cast<bool>(typeofchamp) ? JNI_TRUE : JNI_FALSE);
1032
1033                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateChampjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubledoublejbooleanbooleanID ,parent, vx_, vy_, vfx_, vfy_, arsize, typeofchamp_));
1034                         curEnv->DeleteLocalRef(vx_);
1035 curEnv->DeleteLocalRef(vy_);
1036 curEnv->DeleteLocalRef(vfx_);
1037 curEnv->DeleteLocalRef(vfy_);
1038 if (curEnv->ExceptionCheck()) {
1039 throw GiwsException::JniCallMethodException(curEnv);
1040 }
1041 return res;
1042
1043 }
1044
1045 int Builder::createSurface (JavaVM * jvm_, int parent, int typeof3d, int colorFlag, int colorMode){
1046
1047 JNIEnv * curEnv = NULL;
1048 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1049 jclass cls = initClass(curEnv);
1050 if ( cls == NULL) {
1051 throw GiwsException::JniCallMethodException(curEnv);
1052 }
1053
1054 static jmethodID jintcreateSurfacejintintjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "createSurface", "(IIII)I" ) ;
1055 if (jintcreateSurfacejintintjintintjintintjintintID == NULL) {
1056 throw GiwsException::JniMethodNotFoundException(curEnv, "createSurface");
1057 }
1058
1059                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateSurfacejintintjintintjintintjintintID ,parent, typeof3d, colorFlag, colorMode));
1060                         if (curEnv->ExceptionCheck()) {
1061 throw GiwsException::JniCallMethodException(curEnv);
1062 }
1063 return res;
1064
1065 }
1066
1067 void Builder::initSubWinTo3d (JavaVM * jvm_, int parent, char const* legend, bool isLegend, int const* flag, int flagSize, double alpha, double theta, double const* ebox, int eboxSize, double const* x, int xSize, double const* y, int ySize, double const* z, int zSize){
1068
1069 JNIEnv * curEnv = NULL;
1070 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1071 jclass cls = initClass(curEnv);
1072 if ( cls == NULL) {
1073 throw GiwsException::JniCallMethodException(curEnv);
1074 }
1075
1076 static jmethodID voidinitSubWinTo3djintintjstringjava_lang_StringjbooleanbooleanjintArray_intintjdoubledoublejdoubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID = curEnv->GetStaticMethodID(cls, "initSubWinTo3d", "(ILjava/lang/String;Z[IDD[D[D[D[D)V" ) ;
1077 if (voidinitSubWinTo3djintintjstringjava_lang_StringjbooleanbooleanjintArray_intintjdoubledoublejdoubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID == NULL) {
1078 throw GiwsException::JniMethodNotFoundException(curEnv, "initSubWinTo3d");
1079 }
1080
1081 jstring legend_ = curEnv->NewStringUTF( legend );
1082 if (legend != NULL && legend_ == NULL)
1083 {
1084 throw GiwsException::JniBadAllocException(curEnv);
1085 }
1086
1087
1088 jboolean isLegend_ = (static_cast<bool>(isLegend) ? JNI_TRUE : JNI_FALSE);
1089
1090 jintArray flag_ = curEnv->NewIntArray( flagSize ) ;
1091
1092 if (flag_ == NULL)
1093 {
1094 // check that allocation succeed
1095 throw GiwsException::JniBadAllocException(curEnv);
1096 }
1097
1098 curEnv->SetIntArrayRegion( flag_, 0, flagSize, (jint*)(flag) ) ;
1099
1100
1101 jdoubleArray ebox_ = curEnv->NewDoubleArray( eboxSize ) ;
1102
1103 if (ebox_ == NULL)
1104 {
1105 // check that allocation succeed
1106 throw GiwsException::JniBadAllocException(curEnv);
1107 }
1108
1109 curEnv->SetDoubleArrayRegion( ebox_, 0, eboxSize, (jdouble*)(ebox) ) ;
1110
1111
1112 jdoubleArray x_ = curEnv->NewDoubleArray( xSize ) ;
1113
1114 if (x_ == NULL)
1115 {
1116 // check that allocation succeed
1117 throw GiwsException::JniBadAllocException(curEnv);
1118 }
1119
1120 curEnv->SetDoubleArrayRegion( x_, 0, xSize, (jdouble*)(x) ) ;
1121
1122
1123 jdoubleArray y_ = curEnv->NewDoubleArray( ySize ) ;
1124
1125 if (y_ == NULL)
1126 {
1127 // check that allocation succeed
1128 throw GiwsException::JniBadAllocException(curEnv);
1129 }
1130
1131 curEnv->SetDoubleArrayRegion( y_, 0, ySize, (jdouble*)(y) ) ;
1132
1133
1134 jdoubleArray z_ = curEnv->NewDoubleArray( zSize ) ;
1135
1136 if (z_ == NULL)
1137 {
1138 // check that allocation succeed
1139 throw GiwsException::JniBadAllocException(curEnv);
1140 }
1141
1142 curEnv->SetDoubleArrayRegion( z_, 0, zSize, (jdouble*)(z) ) ;
1143
1144
1145                          curEnv->CallStaticVoidMethod(cls, voidinitSubWinTo3djintintjstringjava_lang_StringjbooleanbooleanjintArray_intintjdoubledoublejdoubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID ,parent, legend_, isLegend_, flag_, alpha, theta, ebox_, x_, y_, z_);
1146                         curEnv->DeleteLocalRef(legend_);
1147 curEnv->DeleteLocalRef(flag_);
1148 curEnv->DeleteLocalRef(ebox_);
1149 curEnv->DeleteLocalRef(x_);
1150 curEnv->DeleteLocalRef(y_);
1151 curEnv->DeleteLocalRef(z_);
1152 if (curEnv->ExceptionCheck()) {
1153 throw GiwsException::JniCallMethodException(curEnv);
1154 }
1155 }
1156
1157 int Builder::createLight (JavaVM * jvm_, int parent, int type, bool visible, double const* pos, int posSize, double const* dir, int dirSize, double const* ambient, int ambientSize, double const* diffuse, int diffuseSize, double const* specular, int specularSize){
1158
1159 JNIEnv * curEnv = NULL;
1160 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1161 jclass cls = initClass(curEnv);
1162 if ( cls == NULL) {
1163 throw GiwsException::JniCallMethodException(curEnv);
1164 }
1165
1166 static jmethodID jintcreateLightjintintjintintjbooleanbooleanjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID = curEnv->GetStaticMethodID(cls, "createLight", "(IIZ[D[D[D[D[D)I" ) ;
1167 if (jintcreateLightjintintjintintjbooleanbooleanjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID == NULL) {
1168 throw GiwsException::JniMethodNotFoundException(curEnv, "createLight");
1169 }
1170
1171 jboolean visible_ = (static_cast<bool>(visible) ? JNI_TRUE : JNI_FALSE);
1172
1173 jdoubleArray pos_ = curEnv->NewDoubleArray( posSize ) ;
1174
1175 if (pos_ == NULL)
1176 {
1177 // check that allocation succeed
1178 throw GiwsException::JniBadAllocException(curEnv);
1179 }
1180
1181 curEnv->SetDoubleArrayRegion( pos_, 0, posSize, (jdouble*)(pos) ) ;
1182
1183
1184 jdoubleArray dir_ = curEnv->NewDoubleArray( dirSize ) ;
1185
1186 if (dir_ == NULL)
1187 {
1188 // check that allocation succeed
1189 throw GiwsException::JniBadAllocException(curEnv);
1190 }
1191
1192 curEnv->SetDoubleArrayRegion( dir_, 0, dirSize, (jdouble*)(dir) ) ;
1193
1194
1195 jdoubleArray ambient_ = curEnv->NewDoubleArray( ambientSize ) ;
1196
1197 if (ambient_ == NULL)
1198 {
1199 // check that allocation succeed
1200 throw GiwsException::JniBadAllocException(curEnv);
1201 }
1202
1203 curEnv->SetDoubleArrayRegion( ambient_, 0, ambientSize, (jdouble*)(ambient) ) ;
1204
1205
1206 jdoubleArray diffuse_ = curEnv->NewDoubleArray( diffuseSize ) ;
1207
1208 if (diffuse_ == NULL)
1209 {
1210 // check that allocation succeed
1211 throw GiwsException::JniBadAllocException(curEnv);
1212 }
1213
1214 curEnv->SetDoubleArrayRegion( diffuse_, 0, diffuseSize, (jdouble*)(diffuse) ) ;
1215
1216
1217 jdoubleArray specular_ = curEnv->NewDoubleArray( specularSize ) ;
1218
1219 if (specular_ == NULL)
1220 {
1221 // check that allocation succeed
1222 throw GiwsException::JniBadAllocException(curEnv);
1223 }
1224
1225 curEnv->SetDoubleArrayRegion( specular_, 0, specularSize, (jdouble*)(specular) ) ;
1226
1227
1228                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateLightjintintjintintjbooleanbooleanjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID ,parent, type, visible_, pos_, dir_, ambient_, diffuse_, specular_));
1229                         curEnv->DeleteLocalRef(pos_);
1230 curEnv->DeleteLocalRef(dir_);
1231 curEnv->DeleteLocalRef(ambient_);
1232 curEnv->DeleteLocalRef(diffuse_);
1233 curEnv->DeleteLocalRef(specular_);
1234 if (curEnv->ExceptionCheck()) {
1235 throw GiwsException::JniCallMethodException(curEnv);
1236 }
1237 return res;
1238
1239 }
1240
1241 }