Add full options management to figure
[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 jintcreateFigurejbooleanbooleanjintintjintintjbooleanbooleanjbooleanbooleanID=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 jintcreateFigurejbooleanbooleanjintintjintintjbooleanbooleanjbooleanbooleanID=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){
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 jintcreateFigurejbooleanbooleanjintintjintintjbooleanbooleanjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "createFigure", "(ZIIZZ)I" ) ;
361 if (jintcreateFigurejbooleanbooleanjintintjintintjbooleanbooleanjbooleanbooleanID == 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                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateFigurejbooleanbooleanjintintjintintjbooleanbooleanjbooleanbooleanID ,dockable_, menubarType, toolbarType, defaultAxes_, visible_));
372                         if (curEnv->ExceptionCheck()) {
373 throw GiwsException::JniCallMethodException(curEnv);
374 }
375 return res;
376
377 }
378
379 void Builder::cloneMenus (JavaVM * jvm_, int model, int newParent){
380
381 JNIEnv * curEnv = NULL;
382 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
383 jclass cls = initClass(curEnv);
384 if ( cls == NULL) {
385 throw GiwsException::JniCallMethodException(curEnv);
386 }
387
388 static jmethodID voidcloneMenusjintintjintintID = curEnv->GetStaticMethodID(cls, "cloneMenus", "(II)V" ) ;
389 if (voidcloneMenusjintintjintintID == NULL) {
390 throw GiwsException::JniMethodNotFoundException(curEnv, "cloneMenus");
391 }
392
393                          curEnv->CallStaticVoidMethod(cls, voidcloneMenusjintintjintintID ,model, newParent);
394                         if (curEnv->ExceptionCheck()) {
395 throw GiwsException::JniCallMethodException(curEnv);
396 }
397 }
398
399 int Builder::cloneAxesModel (JavaVM * jvm_, int parent){
400
401 JNIEnv * curEnv = NULL;
402 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
403 jclass cls = initClass(curEnv);
404 if ( cls == NULL) {
405 throw GiwsException::JniCallMethodException(curEnv);
406 }
407
408 static jmethodID jintcloneAxesModeljintintID = curEnv->GetStaticMethodID(cls, "cloneAxesModel", "(I)I" ) ;
409 if (jintcloneAxesModeljintintID == NULL) {
410 throw GiwsException::JniMethodNotFoundException(curEnv, "cloneAxesModel");
411 }
412
413                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcloneAxesModeljintintID ,parent));
414                         if (curEnv->ExceptionCheck()) {
415 throw GiwsException::JniCallMethodException(curEnv);
416 }
417 return res;
418
419 }
420
421 int Builder::createSubWin (JavaVM * jvm_, int parent){
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 jintcreateSubWinjintintID = curEnv->GetStaticMethodID(cls, "createSubWin", "(I)I" ) ;
431 if (jintcreateSubWinjintintID == NULL) {
432 throw GiwsException::JniMethodNotFoundException(curEnv, "createSubWin");
433 }
434
435                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateSubWinjintintID ,parent));
436                         if (curEnv->ExceptionCheck()) {
437 throw GiwsException::JniCallMethodException(curEnv);
438 }
439 return res;
440
441 }
442
443 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){
444
445 JNIEnv * curEnv = NULL;
446 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
447 jclass cls = initClass(curEnv);
448 if ( cls == NULL) {
449 throw GiwsException::JniCallMethodException(curEnv);
450 }
451
452 static jmethodID jintcreateTextjintintjobjectArray_java_lang_Stringjava_lang_StringjintintjintintjdoubledoublejdoubledoublejbooleanbooleanjdoubleArray_doubledoublejintintjintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "createText", "(I[Ljava/lang/String;IIDDZ[DIIZIZZZZI)I" ) ;
453 if (jintcreateTextjintintjobjectArray_java_lang_Stringjava_lang_StringjintintjintintjdoubledoublejdoubledoublejbooleanbooleanjdoubleArray_doubledoublejintintjintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanjintintID == NULL) {
454 throw GiwsException::JniMethodNotFoundException(curEnv, "createText");
455 }
456 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
457
458 // create java array of strings.
459 jobjectArray text_ = curEnv->NewObjectArray( textSize, stringArrayClass, NULL);
460 if (text_ == NULL)
461 {
462 throw GiwsException::JniBadAllocException(curEnv);
463 }
464
465 // convert each char * to java strings and fill the java array.
466 for ( int i = 0; i < textSize; i++)
467 {
468 jstring TempString = curEnv->NewStringUTF( text[i] );
469 if (TempString == NULL)
470 {
471 throw GiwsException::JniBadAllocException(curEnv);
472 }
473
474 curEnv->SetObjectArrayElement( text_, i, TempString);
475
476 // avoid keeping reference on too many strings
477 curEnv->DeleteLocalRef(TempString);
478 }
479 jboolean autoSize_ = (static_cast<bool>(autoSize) ? JNI_TRUE : JNI_FALSE);
480
481 jdoubleArray userSize_ = curEnv->NewDoubleArray( userSizeSize ) ;
482
483 if (userSize_ == NULL)
484 {
485 // check that allocation succeed
486 throw GiwsException::JniBadAllocException(curEnv);
487 }
488
489 curEnv->SetDoubleArrayRegion( userSize_, 0, userSizeSize, (jdouble*)(userSize) ) ;
490
491
492 jboolean isForeground_ = (static_cast<bool>(isForeground) ? JNI_TRUE : JNI_FALSE);
493
494 jboolean isBackground_ = (static_cast<bool>(isBackground) ? JNI_TRUE : JNI_FALSE);
495
496 jboolean boxed_ = (static_cast<bool>(boxed) ? JNI_TRUE : JNI_FALSE);
497
498 jboolean line_ = (static_cast<bool>(line) ? JNI_TRUE : JNI_FALSE);
499
500 jboolean filled_ = (static_cast<bool>(filled) ? JNI_TRUE : JNI_FALSE);
501
502                         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));
503                         curEnv->DeleteLocalRef(stringArrayClass);
504 curEnv->DeleteLocalRef(text_);
505 curEnv->DeleteLocalRef(userSize_);
506 if (curEnv->ExceptionCheck()) {
507 throw GiwsException::JniCallMethodException(curEnv);
508 }
509 return res;
510
511 }
512
513 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){
514
515 JNIEnv * curEnv = NULL;
516 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
517 jclass cls = initClass(curEnv);
518 if ( cls == NULL) {
519 throw GiwsException::JniCallMethodException(curEnv);
520 }
521
522 static jmethodID jintcreateArcjintintjdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "createArc", "(IDDDDDDIZIZZZ)I" ) ;
523 if (jintcreateArcjintintjdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanID == NULL) {
524 throw GiwsException::JniMethodNotFoundException(curEnv, "createArc");
525 }
526
527 jboolean isForeground_ = (static_cast<bool>(isForeground) ? JNI_TRUE : JNI_FALSE);
528
529 jboolean isBackground_ = (static_cast<bool>(isBackground) ? JNI_TRUE : JNI_FALSE);
530
531 jboolean filled_ = (static_cast<bool>(filled) ? JNI_TRUE : JNI_FALSE);
532
533 jboolean line_ = (static_cast<bool>(line) ? JNI_TRUE : JNI_FALSE);
534
535                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateArcjintintjdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanID ,parent, x, y, h, w, start, end, foreground, isForeground_, background, isBackground_, filled_, line_));
536                         if (curEnv->ExceptionCheck()) {
537 throw GiwsException::JniCallMethodException(curEnv);
538 }
539 return res;
540
541 }
542
543 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){
544
545 JNIEnv * curEnv = NULL;
546 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
547 jclass cls = initClass(curEnv);
548 if ( cls == NULL) {
549 throw GiwsException::JniCallMethodException(curEnv);
550 }
551
552 static jmethodID jintcreateAxisjintintjintintjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintjstringjava_lang_StringjintintjintintjintintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "createAxis", "(III[D[DILjava/lang/String;IIIZ)I" ) ;
553 if (jintcreateAxisjintintjintintjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintjstringjava_lang_StringjintintjintintjintintjbooleanbooleanID == NULL) {
554 throw GiwsException::JniMethodNotFoundException(curEnv, "createAxis");
555 }
556
557 jdoubleArray vx_ = curEnv->NewDoubleArray( vxSize ) ;
558
559 if (vx_ == NULL)
560 {
561 // check that allocation succeed
562 throw GiwsException::JniBadAllocException(curEnv);
563 }
564
565 curEnv->SetDoubleArrayRegion( vx_, 0, vxSize, (jdouble*)(vx) ) ;
566
567
568 jdoubleArray vy_ = curEnv->NewDoubleArray( vySize ) ;
569
570 if (vy_ == NULL)
571 {
572 // check that allocation succeed
573 throw GiwsException::JniBadAllocException(curEnv);
574 }
575
576 curEnv->SetDoubleArrayRegion( vy_, 0, vySize, (jdouble*)(vy) ) ;
577
578
579 jstring format_ = curEnv->NewStringUTF( format );
580 if (format != NULL && format_ == NULL)
581 {
582 throw GiwsException::JniBadAllocException(curEnv);
583 }
584
585
586 jboolean seg_ = (static_cast<bool>(seg) ? JNI_TRUE : JNI_FALSE);
587
588                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateAxisjintintjintintjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintjstringjava_lang_StringjintintjintintjintintjbooleanbooleanID ,parent, dir, tics, vx_, vy_, subint, format_, fontSize, textColor, ticsColor, seg_));
589                         curEnv->DeleteLocalRef(vx_);
590 curEnv->DeleteLocalRef(vy_);
591 curEnv->DeleteLocalRef(format_);
592 if (curEnv->ExceptionCheck()) {
593 throw GiwsException::JniCallMethodException(curEnv);
594 }
595 return res;
596
597 }
598
599 int Builder::createCompound (JavaVM * jvm_, int parent, int const* children, int childrenSize){
600
601 JNIEnv * curEnv = NULL;
602 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
603 jclass cls = initClass(curEnv);
604 if ( cls == NULL) {
605 throw GiwsException::JniCallMethodException(curEnv);
606 }
607
608 static jmethodID jintcreateCompoundjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "createCompound", "(I[I)I" ) ;
609 if (jintcreateCompoundjintintjintArray_intintID == NULL) {
610 throw GiwsException::JniMethodNotFoundException(curEnv, "createCompound");
611 }
612
613 jintArray children_ = curEnv->NewIntArray( childrenSize ) ;
614
615 if (children_ == NULL)
616 {
617 // check that allocation succeed
618 throw GiwsException::JniBadAllocException(curEnv);
619 }
620
621 curEnv->SetIntArrayRegion( children_, 0, childrenSize, (jint*)(children) ) ;
622
623
624                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateCompoundjintintjintArray_intintID ,parent, children_));
625                         curEnv->DeleteLocalRef(children_);
626 if (curEnv->ExceptionCheck()) {
627 throw GiwsException::JniCallMethodException(curEnv);
628 }
629 return res;
630
631 }
632
633 int Builder::createCompoundSeq (JavaVM * jvm_, int parent, int childrenCount){
634
635 JNIEnv * curEnv = NULL;
636 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
637 jclass cls = initClass(curEnv);
638 if ( cls == NULL) {
639 throw GiwsException::JniCallMethodException(curEnv);
640 }
641
642 static jmethodID jintcreateCompoundSeqjintintjintintID = curEnv->GetStaticMethodID(cls, "createCompoundSeq", "(II)I" ) ;
643 if (jintcreateCompoundSeqjintintjintintID == NULL) {
644 throw GiwsException::JniMethodNotFoundException(curEnv, "createCompoundSeq");
645 }
646
647                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateCompoundSeqjintintjintintID ,parent, childrenCount));
648                         if (curEnv->ExceptionCheck()) {
649 throw GiwsException::JniCallMethodException(curEnv);
650 }
651 return res;
652
653 }
654
655 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){
656
657 JNIEnv * curEnv = NULL;
658 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
659 jclass cls = initClass(curEnv);
660 if ( cls == NULL) {
661 throw GiwsException::JniCallMethodException(curEnv);
662 }
663
664 static jmethodID jintcreateFecjintintjdoubleArray_doubledoublejintArray_intintjintArray_intintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "createFec", "(I[D[I[IZ)I" ) ;
665 if (jintcreateFecjintintjdoubleArray_doubledoublejintArray_intintjintArray_intintjbooleanbooleanID == NULL) {
666 throw GiwsException::JniMethodNotFoundException(curEnv, "createFec");
667 }
668
669 jdoubleArray zminmax_ = curEnv->NewDoubleArray( zminmaxSize ) ;
670
671 if (zminmax_ == NULL)
672 {
673 // check that allocation succeed
674 throw GiwsException::JniBadAllocException(curEnv);
675 }
676
677 curEnv->SetDoubleArrayRegion( zminmax_, 0, zminmaxSize, (jdouble*)(zminmax) ) ;
678
679
680 jintArray colminmax_ = curEnv->NewIntArray( colminmaxSize ) ;
681
682 if (colminmax_ == NULL)
683 {
684 // check that allocation succeed
685 throw GiwsException::JniBadAllocException(curEnv);
686 }
687
688 curEnv->SetIntArrayRegion( colminmax_, 0, colminmaxSize, (jint*)(colminmax) ) ;
689
690
691 jintArray colout_ = curEnv->NewIntArray( coloutSize ) ;
692
693 if (colout_ == NULL)
694 {
695 // check that allocation succeed
696 throw GiwsException::JniBadAllocException(curEnv);
697 }
698
699 curEnv->SetIntArrayRegion( colout_, 0, coloutSize, (jint*)(colout) ) ;
700
701
702 jboolean with_mesh_ = (static_cast<bool>(with_mesh) ? JNI_TRUE : JNI_FALSE);
703
704                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateFecjintintjdoubleArray_doubledoublejintArray_intintjintArray_intintjbooleanbooleanID ,parent, zminmax_, colminmax_, colout_, with_mesh_));
705                         curEnv->DeleteLocalRef(zminmax_);
706 curEnv->DeleteLocalRef(colminmax_);
707 curEnv->DeleteLocalRef(colout_);
708 if (curEnv->ExceptionCheck()) {
709 throw GiwsException::JniCallMethodException(curEnv);
710 }
711 return res;
712
713 }
714
715 int Builder::createGrayplot (JavaVM * jvm_, int parent, int type, double const* pvecx, int pvecxSize, int n1, int n2){
716
717 JNIEnv * curEnv = NULL;
718 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
719 jclass cls = initClass(curEnv);
720 if ( cls == NULL) {
721 throw GiwsException::JniCallMethodException(curEnv);
722 }
723
724 static jmethodID jintcreateGrayplotjintintjintintjdoubleArray_doubledoublejintintjintintID = curEnv->GetStaticMethodID(cls, "createGrayplot", "(II[DII)I" ) ;
725 if (jintcreateGrayplotjintintjintintjdoubleArray_doubledoublejintintjintintID == NULL) {
726 throw GiwsException::JniMethodNotFoundException(curEnv, "createGrayplot");
727 }
728
729 jdoubleArray pvecx_ = curEnv->NewDoubleArray( pvecxSize ) ;
730
731 if (pvecx_ == NULL)
732 {
733 // check that allocation succeed
734 throw GiwsException::JniBadAllocException(curEnv);
735 }
736
737 curEnv->SetDoubleArrayRegion( pvecx_, 0, pvecxSize, (jdouble*)(pvecx) ) ;
738
739
740                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateGrayplotjintintjintintjdoubleArray_doubledoublejintintjintintID ,parent, type, pvecx_, n1, n2));
741                         curEnv->DeleteLocalRef(pvecx_);
742 if (curEnv->ExceptionCheck()) {
743 throw GiwsException::JniCallMethodException(curEnv);
744 }
745 return res;
746
747 }
748
749 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){
750
751 JNIEnv * curEnv = NULL;
752 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
753 jclass cls = initClass(curEnv);
754 if ( cls == NULL) {
755 throw GiwsException::JniCallMethodException(curEnv);
756 }
757
758 static jmethodID jintcreatePolylinejintintjbooleanbooleanjintintjintintjbooleanbooleanjintArray_intintjintintjbooleanbooleanjintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "createPolyline", "(IZIIZ[IIZIZIZZZZZ)I" ) ;
759 if (jintcreatePolylinejintintjbooleanbooleanjintintjintintjbooleanbooleanjintArray_intintjintintjbooleanbooleanjintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanID == NULL) {
760 throw GiwsException::JniMethodNotFoundException(curEnv, "createPolyline");
761 }
762
763 jboolean closed_ = (static_cast<bool>(closed) ? JNI_TRUE : JNI_FALSE);
764
765 jboolean isForeground_ = (static_cast<bool>(isForeground) ? JNI_TRUE : JNI_FALSE);
766
767 jintArray background_ = curEnv->NewIntArray( backgroundSize ) ;
768
769 if (background_ == NULL)
770 {
771 // check that allocation succeed
772 throw GiwsException::JniBadAllocException(curEnv);
773 }
774
775 curEnv->SetIntArrayRegion( background_, 0, backgroundSize, (jint*)(background) ) ;
776
777
778 jboolean isMarkStyle_ = (static_cast<bool>(isMarkStyle) ? JNI_TRUE : JNI_FALSE);
779
780 jboolean isMarkForeground_ = (static_cast<bool>(isMarkForeground) ? JNI_TRUE : JNI_FALSE);
781
782 jboolean isMarkBackground_ = (static_cast<bool>(isMarkBackground) ? JNI_TRUE : JNI_FALSE);
783
784 jboolean isline_ = (static_cast<bool>(isline) ? JNI_TRUE : JNI_FALSE);
785
786 jboolean isfilled_ = (static_cast<bool>(isfilled) ? JNI_TRUE : JNI_FALSE);
787
788 jboolean ismark_ = (static_cast<bool>(ismark) ? JNI_TRUE : JNI_FALSE);
789
790 jboolean isinterp_ = (static_cast<bool>(isinterp) ? JNI_TRUE : JNI_FALSE);
791
792                         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_));
793                         curEnv->DeleteLocalRef(background_);
794 if (curEnv->ExceptionCheck()) {
795 throw GiwsException::JniCallMethodException(curEnv);
796 }
797 return res;
798
799 }
800
801 int Builder::createLegend (JavaVM * jvm_, int parent, char const* const* text, int textSize, int const* handles, int handlesSize){
802
803 JNIEnv * curEnv = NULL;
804 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
805 jclass cls = initClass(curEnv);
806 if ( cls == NULL) {
807 throw GiwsException::JniCallMethodException(curEnv);
808 }
809
810 static jmethodID jintcreateLegendjintintjobjectArray_java_lang_Stringjava_lang_StringjintArray_intintID = curEnv->GetStaticMethodID(cls, "createLegend", "(I[Ljava/lang/String;[I)I" ) ;
811 if (jintcreateLegendjintintjobjectArray_java_lang_Stringjava_lang_StringjintArray_intintID == NULL) {
812 throw GiwsException::JniMethodNotFoundException(curEnv, "createLegend");
813 }
814 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
815
816 // create java array of strings.
817 jobjectArray text_ = curEnv->NewObjectArray( textSize, stringArrayClass, NULL);
818 if (text_ == NULL)
819 {
820 throw GiwsException::JniBadAllocException(curEnv);
821 }
822
823 // convert each char * to java strings and fill the java array.
824 for ( int i = 0; i < textSize; i++)
825 {
826 jstring TempString = curEnv->NewStringUTF( text[i] );
827 if (TempString == NULL)
828 {
829 throw GiwsException::JniBadAllocException(curEnv);
830 }
831
832 curEnv->SetObjectArrayElement( text_, i, TempString);
833
834 // avoid keeping reference on too many strings
835 curEnv->DeleteLocalRef(TempString);
836 }
837 jintArray handles_ = curEnv->NewIntArray( handlesSize ) ;
838
839 if (handles_ == NULL)
840 {
841 // check that allocation succeed
842 throw GiwsException::JniBadAllocException(curEnv);
843 }
844
845 curEnv->SetIntArrayRegion( handles_, 0, handlesSize, (jint*)(handles) ) ;
846
847
848                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateLegendjintintjobjectArray_java_lang_Stringjava_lang_StringjintArray_intintID ,parent, text_, handles_));
849                         curEnv->DeleteLocalRef(stringArrayClass);
850 curEnv->DeleteLocalRef(text_);
851 curEnv->DeleteLocalRef(handles_);
852 if (curEnv->ExceptionCheck()) {
853 throw GiwsException::JniCallMethodException(curEnv);
854 }
855 return res;
856
857 }
858
859 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){
860
861 JNIEnv * curEnv = NULL;
862 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
863 jclass cls = initClass(curEnv);
864 if ( cls == NULL) {
865 throw GiwsException::JniCallMethodException(curEnv);
866 }
867
868 static jmethodID jintcreateSegsjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejbooleanbooleanjintArray_intintjdoubledoubleID = curEnv->GetStaticMethodID(cls, "createSegs", "(I[D[D[DZ[ID)I" ) ;
869 if (jintcreateSegsjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejbooleanbooleanjintArray_intintjdoubledoubleID == NULL) {
870 throw GiwsException::JniMethodNotFoundException(curEnv, "createSegs");
871 }
872
873 jdoubleArray vx_ = curEnv->NewDoubleArray( vxSize ) ;
874
875 if (vx_ == NULL)
876 {
877 // check that allocation succeed
878 throw GiwsException::JniBadAllocException(curEnv);
879 }
880
881 curEnv->SetDoubleArrayRegion( vx_, 0, vxSize, (jdouble*)(vx) ) ;
882
883
884 jdoubleArray vy_ = curEnv->NewDoubleArray( vySize ) ;
885
886 if (vy_ == NULL)
887 {
888 // check that allocation succeed
889 throw GiwsException::JniBadAllocException(curEnv);
890 }
891
892 curEnv->SetDoubleArrayRegion( vy_, 0, vySize, (jdouble*)(vy) ) ;
893
894
895 jdoubleArray vz_ = curEnv->NewDoubleArray( vzSize ) ;
896
897 if (vz_ == NULL)
898 {
899 // check that allocation succeed
900 throw GiwsException::JniBadAllocException(curEnv);
901 }
902
903 curEnv->SetDoubleArrayRegion( vz_, 0, vzSize, (jdouble*)(vz) ) ;
904
905
906 jboolean isVZ_ = (static_cast<bool>(isVZ) ? JNI_TRUE : JNI_FALSE);
907
908 jintArray style_ = curEnv->NewIntArray( styleSize ) ;
909
910 if (style_ == NULL)
911 {
912 // check that allocation succeed
913 throw GiwsException::JniBadAllocException(curEnv);
914 }
915
916 curEnv->SetIntArrayRegion( style_, 0, styleSize, (jint*)(style) ) ;
917
918
919                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateSegsjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejbooleanbooleanjintArray_intintjdoubledoubleID ,parent, vx_, vy_, vz_, isVZ_, style_, arsize));
920                         curEnv->DeleteLocalRef(vx_);
921 curEnv->DeleteLocalRef(vy_);
922 curEnv->DeleteLocalRef(vz_);
923 curEnv->DeleteLocalRef(style_);
924 if (curEnv->ExceptionCheck()) {
925 throw GiwsException::JniCallMethodException(curEnv);
926 }
927 return res;
928
929 }
930
931 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){
932
933 JNIEnv * curEnv = NULL;
934 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
935 jclass cls = initClass(curEnv);
936 if ( cls == NULL) {
937 throw GiwsException::JniCallMethodException(curEnv);
938 }
939
940 static jmethodID jintcreateChampjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubledoublejbooleanbooleanID = curEnv->GetStaticMethodID(cls, "createChamp", "(I[D[D[D[DDZ)I" ) ;
941 if (jintcreateChampjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubledoublejbooleanbooleanID == NULL) {
942 throw GiwsException::JniMethodNotFoundException(curEnv, "createChamp");
943 }
944
945 jdoubleArray vx_ = curEnv->NewDoubleArray( vxSize ) ;
946
947 if (vx_ == NULL)
948 {
949 // check that allocation succeed
950 throw GiwsException::JniBadAllocException(curEnv);
951 }
952
953 curEnv->SetDoubleArrayRegion( vx_, 0, vxSize, (jdouble*)(vx) ) ;
954
955
956 jdoubleArray vy_ = curEnv->NewDoubleArray( vySize ) ;
957
958 if (vy_ == NULL)
959 {
960 // check that allocation succeed
961 throw GiwsException::JniBadAllocException(curEnv);
962 }
963
964 curEnv->SetDoubleArrayRegion( vy_, 0, vySize, (jdouble*)(vy) ) ;
965
966
967 jdoubleArray vfx_ = curEnv->NewDoubleArray( vfxSize ) ;
968
969 if (vfx_ == NULL)
970 {
971 // check that allocation succeed
972 throw GiwsException::JniBadAllocException(curEnv);
973 }
974
975 curEnv->SetDoubleArrayRegion( vfx_, 0, vfxSize, (jdouble*)(vfx) ) ;
976
977
978 jdoubleArray vfy_ = curEnv->NewDoubleArray( vfySize ) ;
979
980 if (vfy_ == NULL)
981 {
982 // check that allocation succeed
983 throw GiwsException::JniBadAllocException(curEnv);
984 }
985
986 curEnv->SetDoubleArrayRegion( vfy_, 0, vfySize, (jdouble*)(vfy) ) ;
987
988
989 jboolean typeofchamp_ = (static_cast<bool>(typeofchamp) ? JNI_TRUE : JNI_FALSE);
990
991                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateChampjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubledoublejbooleanbooleanID ,parent, vx_, vy_, vfx_, vfy_, arsize, typeofchamp_));
992                         curEnv->DeleteLocalRef(vx_);
993 curEnv->DeleteLocalRef(vy_);
994 curEnv->DeleteLocalRef(vfx_);
995 curEnv->DeleteLocalRef(vfy_);
996 if (curEnv->ExceptionCheck()) {
997 throw GiwsException::JniCallMethodException(curEnv);
998 }
999 return res;
1000
1001 }
1002
1003 int Builder::createSurface (JavaVM * jvm_, int parent, int typeof3d, int colorFlag, int colorMode){
1004
1005 JNIEnv * curEnv = NULL;
1006 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1007 jclass cls = initClass(curEnv);
1008 if ( cls == NULL) {
1009 throw GiwsException::JniCallMethodException(curEnv);
1010 }
1011
1012 static jmethodID jintcreateSurfacejintintjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "createSurface", "(IIII)I" ) ;
1013 if (jintcreateSurfacejintintjintintjintintjintintID == NULL) {
1014 throw GiwsException::JniMethodNotFoundException(curEnv, "createSurface");
1015 }
1016
1017                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateSurfacejintintjintintjintintjintintID ,parent, typeof3d, colorFlag, colorMode));
1018                         if (curEnv->ExceptionCheck()) {
1019 throw GiwsException::JniCallMethodException(curEnv);
1020 }
1021 return res;
1022
1023 }
1024
1025 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){
1026
1027 JNIEnv * curEnv = NULL;
1028 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1029 jclass cls = initClass(curEnv);
1030 if ( cls == NULL) {
1031 throw GiwsException::JniCallMethodException(curEnv);
1032 }
1033
1034 static jmethodID voidinitSubWinTo3djintintjstringjava_lang_StringjbooleanbooleanjintArray_intintjdoubledoublejdoubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID = curEnv->GetStaticMethodID(cls, "initSubWinTo3d", "(ILjava/lang/String;Z[IDD[D[D[D[D)V" ) ;
1035 if (voidinitSubWinTo3djintintjstringjava_lang_StringjbooleanbooleanjintArray_intintjdoubledoublejdoubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID == NULL) {
1036 throw GiwsException::JniMethodNotFoundException(curEnv, "initSubWinTo3d");
1037 }
1038
1039 jstring legend_ = curEnv->NewStringUTF( legend );
1040 if (legend != NULL && legend_ == NULL)
1041 {
1042 throw GiwsException::JniBadAllocException(curEnv);
1043 }
1044
1045
1046 jboolean isLegend_ = (static_cast<bool>(isLegend) ? JNI_TRUE : JNI_FALSE);
1047
1048 jintArray flag_ = curEnv->NewIntArray( flagSize ) ;
1049
1050 if (flag_ == NULL)
1051 {
1052 // check that allocation succeed
1053 throw GiwsException::JniBadAllocException(curEnv);
1054 }
1055
1056 curEnv->SetIntArrayRegion( flag_, 0, flagSize, (jint*)(flag) ) ;
1057
1058
1059 jdoubleArray ebox_ = curEnv->NewDoubleArray( eboxSize ) ;
1060
1061 if (ebox_ == NULL)
1062 {
1063 // check that allocation succeed
1064 throw GiwsException::JniBadAllocException(curEnv);
1065 }
1066
1067 curEnv->SetDoubleArrayRegion( ebox_, 0, eboxSize, (jdouble*)(ebox) ) ;
1068
1069
1070 jdoubleArray x_ = curEnv->NewDoubleArray( xSize ) ;
1071
1072 if (x_ == NULL)
1073 {
1074 // check that allocation succeed
1075 throw GiwsException::JniBadAllocException(curEnv);
1076 }
1077
1078 curEnv->SetDoubleArrayRegion( x_, 0, xSize, (jdouble*)(x) ) ;
1079
1080
1081 jdoubleArray y_ = curEnv->NewDoubleArray( ySize ) ;
1082
1083 if (y_ == NULL)
1084 {
1085 // check that allocation succeed
1086 throw GiwsException::JniBadAllocException(curEnv);
1087 }
1088
1089 curEnv->SetDoubleArrayRegion( y_, 0, ySize, (jdouble*)(y) ) ;
1090
1091
1092 jdoubleArray z_ = curEnv->NewDoubleArray( zSize ) ;
1093
1094 if (z_ == NULL)
1095 {
1096 // check that allocation succeed
1097 throw GiwsException::JniBadAllocException(curEnv);
1098 }
1099
1100 curEnv->SetDoubleArrayRegion( z_, 0, zSize, (jdouble*)(z) ) ;
1101
1102
1103                          curEnv->CallStaticVoidMethod(cls, voidinitSubWinTo3djintintjstringjava_lang_StringjbooleanbooleanjintArray_intintjdoubledoublejdoubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID ,parent, legend_, isLegend_, flag_, alpha, theta, ebox_, x_, y_, z_);
1104                         curEnv->DeleteLocalRef(legend_);
1105 curEnv->DeleteLocalRef(flag_);
1106 curEnv->DeleteLocalRef(ebox_);
1107 curEnv->DeleteLocalRef(x_);
1108 curEnv->DeleteLocalRef(y_);
1109 curEnv->DeleteLocalRef(z_);
1110 if (curEnv->ExceptionCheck()) {
1111 throw GiwsException::JniCallMethodException(curEnv);
1112 }
1113 }
1114
1115 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){
1116
1117 JNIEnv * curEnv = NULL;
1118 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1119 jclass cls = initClass(curEnv);
1120 if ( cls == NULL) {
1121 throw GiwsException::JniCallMethodException(curEnv);
1122 }
1123
1124 static jmethodID jintcreateLightjintintjintintjbooleanbooleanjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID = curEnv->GetStaticMethodID(cls, "createLight", "(IIZ[D[D[D[D[D)I" ) ;
1125 if (jintcreateLightjintintjintintjbooleanbooleanjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID == NULL) {
1126 throw GiwsException::JniMethodNotFoundException(curEnv, "createLight");
1127 }
1128
1129 jboolean visible_ = (static_cast<bool>(visible) ? JNI_TRUE : JNI_FALSE);
1130
1131 jdoubleArray pos_ = curEnv->NewDoubleArray( posSize ) ;
1132
1133 if (pos_ == NULL)
1134 {
1135 // check that allocation succeed
1136 throw GiwsException::JniBadAllocException(curEnv);
1137 }
1138
1139 curEnv->SetDoubleArrayRegion( pos_, 0, posSize, (jdouble*)(pos) ) ;
1140
1141
1142 jdoubleArray dir_ = curEnv->NewDoubleArray( dirSize ) ;
1143
1144 if (dir_ == NULL)
1145 {
1146 // check that allocation succeed
1147 throw GiwsException::JniBadAllocException(curEnv);
1148 }
1149
1150 curEnv->SetDoubleArrayRegion( dir_, 0, dirSize, (jdouble*)(dir) ) ;
1151
1152
1153 jdoubleArray ambient_ = curEnv->NewDoubleArray( ambientSize ) ;
1154
1155 if (ambient_ == NULL)
1156 {
1157 // check that allocation succeed
1158 throw GiwsException::JniBadAllocException(curEnv);
1159 }
1160
1161 curEnv->SetDoubleArrayRegion( ambient_, 0, ambientSize, (jdouble*)(ambient) ) ;
1162
1163
1164 jdoubleArray diffuse_ = curEnv->NewDoubleArray( diffuseSize ) ;
1165
1166 if (diffuse_ == NULL)
1167 {
1168 // check that allocation succeed
1169 throw GiwsException::JniBadAllocException(curEnv);
1170 }
1171
1172 curEnv->SetDoubleArrayRegion( diffuse_, 0, diffuseSize, (jdouble*)(diffuse) ) ;
1173
1174
1175 jdoubleArray specular_ = curEnv->NewDoubleArray( specularSize ) ;
1176
1177 if (specular_ == NULL)
1178 {
1179 // check that allocation succeed
1180 throw GiwsException::JniBadAllocException(curEnv);
1181 }
1182
1183 curEnv->SetDoubleArrayRegion( specular_, 0, specularSize, (jdouble*)(specular) ) ;
1184
1185
1186                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateLightjintintjintintjbooleanbooleanjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID ,parent, type, visible_, pos_, dir_, ambient_, diffuse_, specular_));
1187                         curEnv->DeleteLocalRef(pos_);
1188 curEnv->DeleteLocalRef(dir_);
1189 curEnv->DeleteLocalRef(ambient_);
1190 curEnv->DeleteLocalRef(diffuse_);
1191 curEnv->DeleteLocalRef(specular_);
1192 if (curEnv->ExceptionCheck()) {
1193 throw GiwsException::JniCallMethodException(curEnv);
1194 }
1195 return res;
1196
1197 }
1198
1199 }