018204c15f39822dcb4115be2ef4805fb4f62ef7
[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 . --throws-exception-on-error --description-file 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 voidcloneMenusjintintjintintID=NULL;
114 jintcloneAxesModeljintintID=NULL;
115 jintcreateSubWinjintintID=NULL;
116 jintcreateTextjintintjobjectArray_java_lang_Stringjava_lang_StringjintintjintintjdoubledoublejdoubledoublejbooleanbooleanjdoubleArray_doubledoublejintintjintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanjintintID=NULL;
117 jintcreateArcjintintjdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanID=NULL;
118 jintcreateAxisjintintjintintjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintjstringjava_lang_StringjintintjintintjintintjbooleanbooleanID=NULL;
119 jintcreateCompoundjintintjintArray_intintID=NULL;
120 jintcreateCompoundSeqjintintjintintID=NULL;
121 jintcreateFecjintintjdoubleArray_doubledoublejintArray_intintjintArray_intintjbooleanbooleanID=NULL;
122 jintcreateGrayplotjintintjintintjdoubleArray_doubledoublejintintjintintID=NULL;
123 jintcreatePolylinejintintjbooleanbooleanjintintjintintjbooleanbooleanjintArray_intintjintintjbooleanbooleanjintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanID=NULL;
124 jintcreateLegendjintintjobjectArray_java_lang_Stringjava_lang_StringjintArray_intintID=NULL;
125 jintcreateSegsjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejbooleanbooleanjintArray_intintjdoubledoubleID=NULL;
126 jintcreateChampjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubledoublejbooleanbooleanID=NULL;
127 jintcreateSurfacejintintjintintjintintjintintID=NULL;
128 voidinitSubWinTo3djintintjstringjava_lang_StringjbooleanbooleanjintArray_intintjdoubledoublejdoubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID=NULL;
129 jintcreateLightjintintjintintjbooleanbooleanjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID=NULL;
130
131
132 }
133
134 Builder::Builder(JavaVM * jvm_, jobject JObj) {
135         jvm=jvm_;
136
137         JNIEnv * curEnv = getCurrentEnv();
138
139 jclass localClass = curEnv->GetObjectClass(JObj);
140         this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
141         curEnv->DeleteLocalRef(localClass);
142
143         if (this->instanceClass == NULL) {
144 throw GiwsException::JniObjectCreationException(curEnv, this->className());
145         }
146
147         this->instance = curEnv->NewGlobalRef(JObj) ;
148         if(this->instance == NULL){
149 throw GiwsException::JniObjectCreationException(curEnv, this->className());
150         }
151         /* Methods ID set to NULL */
152         jintcreateRectjintintjdoubledoublejdoubledoublejdoubledoublejdoubledoublejintintjintintjintintjintintID=NULL;
153 jintcloneGraphicContextjintintjintintID=NULL;
154 jintcloneFontContextjintintjintintID=NULL;
155 jintcreateHiddenLabeljintintID=NULL;
156 jbooleanisAxesRedrawingjintintID=NULL;
157 jintcreateLabeljintintjintintID=NULL;
158 jintcreateNewFigureWithAxesID=NULL;
159 voidcloneMenusjintintjintintID=NULL;
160 jintcloneAxesModeljintintID=NULL;
161 jintcreateSubWinjintintID=NULL;
162 jintcreateTextjintintjobjectArray_java_lang_Stringjava_lang_StringjintintjintintjdoubledoublejdoubledoublejbooleanbooleanjdoubleArray_doubledoublejintintjintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanjintintID=NULL;
163 jintcreateArcjintintjdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanID=NULL;
164 jintcreateAxisjintintjintintjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintjstringjava_lang_StringjintintjintintjintintjbooleanbooleanID=NULL;
165 jintcreateCompoundjintintjintArray_intintID=NULL;
166 jintcreateCompoundSeqjintintjintintID=NULL;
167 jintcreateFecjintintjdoubleArray_doubledoublejintArray_intintjintArray_intintjbooleanbooleanID=NULL;
168 jintcreateGrayplotjintintjintintjdoubleArray_doubledoublejintintjintintID=NULL;
169 jintcreatePolylinejintintjbooleanbooleanjintintjintintjbooleanbooleanjintArray_intintjintintjbooleanbooleanjintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanID=NULL;
170 jintcreateLegendjintintjobjectArray_java_lang_Stringjava_lang_StringjintArray_intintID=NULL;
171 jintcreateSegsjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejbooleanbooleanjintArray_intintjdoubledoubleID=NULL;
172 jintcreateChampjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubledoublejbooleanbooleanID=NULL;
173 jintcreateSurfacejintintjintintjintintjintintID=NULL;
174 voidinitSubWinTo3djintintjstringjava_lang_StringjbooleanbooleanjintArray_intintjdoubledoublejdoubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID=NULL;
175 jintcreateLightjintintjintintjbooleanbooleanjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID=NULL;
176
177
178 }
179
180 // Generic methods
181
182 void Builder::synchronize() {
183 if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
184 throw GiwsException::JniMonitorException(getCurrentEnv(), "Builder");
185 }
186 }
187
188 void Builder::endSynchronize() {
189 if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
190 throw GiwsException::JniMonitorException(getCurrentEnv(), "Builder");
191 }
192 }
193 // Method(s)
194
195 int Builder::createRect (JavaVM * jvm_, int pparentsubwinUID, double x, double y, double height, double width, int foreground, int background, int isfilled, int isline){
196
197 JNIEnv * curEnv = NULL;
198 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
199 jclass cls = initClass(curEnv);
200 if ( cls == NULL) {
201 throw GiwsException::JniCallMethodException(curEnv);
202 }
203
204 static jmethodID jintcreateRectjintintjdoubledoublejdoubledoublejdoubledoublejdoubledoublejintintjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "createRect", "(IDDDDIIII)I" ) ;
205 if (jintcreateRectjintintjdoubledoublejdoubledoublejdoubledoublejdoubledoublejintintjintintjintintjintintID == NULL) {
206 throw GiwsException::JniMethodNotFoundException(curEnv, "createRect");
207 }
208
209                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateRectjintintjdoubledoublejdoubledoublejdoubledoublejdoubledoublejintintjintintjintintjintintID ,pparentsubwinUID, x, y, height, width, foreground, background, isfilled, isline));
210                         if (curEnv->ExceptionCheck()) {
211 throw GiwsException::JniCallMethodException(curEnv);
212 }
213 return res;
214
215 }
216
217 int Builder::cloneGraphicContext (JavaVM * jvm_, int sourceIdentifier, int destIdentifier){
218
219 JNIEnv * curEnv = NULL;
220 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
221 jclass cls = initClass(curEnv);
222 if ( cls == NULL) {
223 throw GiwsException::JniCallMethodException(curEnv);
224 }
225
226 static jmethodID jintcloneGraphicContextjintintjintintID = curEnv->GetStaticMethodID(cls, "cloneGraphicContext", "(II)I" ) ;
227 if (jintcloneGraphicContextjintintjintintID == NULL) {
228 throw GiwsException::JniMethodNotFoundException(curEnv, "cloneGraphicContext");
229 }
230
231                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcloneGraphicContextjintintjintintID ,sourceIdentifier, destIdentifier));
232                         if (curEnv->ExceptionCheck()) {
233 throw GiwsException::JniCallMethodException(curEnv);
234 }
235 return res;
236
237 }
238
239 int Builder::cloneFontContext (JavaVM * jvm_, int sourceIdentifier, int destIdentifier){
240
241 JNIEnv * curEnv = NULL;
242 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
243 jclass cls = initClass(curEnv);
244 if ( cls == NULL) {
245 throw GiwsException::JniCallMethodException(curEnv);
246 }
247
248 static jmethodID jintcloneFontContextjintintjintintID = curEnv->GetStaticMethodID(cls, "cloneFontContext", "(II)I" ) ;
249 if (jintcloneFontContextjintintjintintID == NULL) {
250 throw GiwsException::JniMethodNotFoundException(curEnv, "cloneFontContext");
251 }
252
253                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcloneFontContextjintintjintintID ,sourceIdentifier, destIdentifier));
254                         if (curEnv->ExceptionCheck()) {
255 throw GiwsException::JniCallMethodException(curEnv);
256 }
257 return res;
258
259 }
260
261 int Builder::createHiddenLabel (JavaVM * jvm_, int parent){
262
263 JNIEnv * curEnv = NULL;
264 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
265 jclass cls = initClass(curEnv);
266 if ( cls == NULL) {
267 throw GiwsException::JniCallMethodException(curEnv);
268 }
269
270 static jmethodID jintcreateHiddenLabeljintintID = curEnv->GetStaticMethodID(cls, "createHiddenLabel", "(I)I" ) ;
271 if (jintcreateHiddenLabeljintintID == NULL) {
272 throw GiwsException::JniMethodNotFoundException(curEnv, "createHiddenLabel");
273 }
274
275                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateHiddenLabeljintintID ,parent));
276                         if (curEnv->ExceptionCheck()) {
277 throw GiwsException::JniCallMethodException(curEnv);
278 }
279 return res;
280
281 }
282
283 bool Builder::isAxesRedrawing (JavaVM * jvm_, int subWin){
284
285 JNIEnv * curEnv = NULL;
286 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
287 jclass cls = initClass(curEnv);
288 if ( cls == NULL) {
289 throw GiwsException::JniCallMethodException(curEnv);
290 }
291
292 static jmethodID jbooleanisAxesRedrawingjintintID = curEnv->GetStaticMethodID(cls, "isAxesRedrawing", "(I)Z" ) ;
293 if (jbooleanisAxesRedrawingjintintID == NULL) {
294 throw GiwsException::JniMethodNotFoundException(curEnv, "isAxesRedrawing");
295 }
296
297                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanisAxesRedrawingjintintID ,subWin));
298                         if (curEnv->ExceptionCheck()) {
299 throw GiwsException::JniCallMethodException(curEnv);
300 }
301 return (res == JNI_TRUE);
302
303 }
304
305 int Builder::createLabel (JavaVM * jvm_, int parent, int type){
306
307 JNIEnv * curEnv = NULL;
308 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
309 jclass cls = initClass(curEnv);
310 if ( cls == NULL) {
311 throw GiwsException::JniCallMethodException(curEnv);
312 }
313
314 static jmethodID jintcreateLabeljintintjintintID = curEnv->GetStaticMethodID(cls, "createLabel", "(II)I" ) ;
315 if (jintcreateLabeljintintjintintID == NULL) {
316 throw GiwsException::JniMethodNotFoundException(curEnv, "createLabel");
317 }
318
319                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateLabeljintintjintintID ,parent, type));
320                         if (curEnv->ExceptionCheck()) {
321 throw GiwsException::JniCallMethodException(curEnv);
322 }
323 return res;
324
325 }
326
327 int Builder::createNewFigureWithAxes (JavaVM * jvm_){
328
329 JNIEnv * curEnv = NULL;
330 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
331 jclass cls = initClass(curEnv);
332 if ( cls == NULL) {
333 throw GiwsException::JniCallMethodException(curEnv);
334 }
335
336 static jmethodID jintcreateNewFigureWithAxesID = curEnv->GetStaticMethodID(cls, "createNewFigureWithAxes", "()I" ) ;
337 if (jintcreateNewFigureWithAxesID == NULL) {
338 throw GiwsException::JniMethodNotFoundException(curEnv, "createNewFigureWithAxes");
339 }
340
341                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateNewFigureWithAxesID ));
342                         if (curEnv->ExceptionCheck()) {
343 throw GiwsException::JniCallMethodException(curEnv);
344 }
345 return res;
346
347 }
348
349 void Builder::cloneMenus (JavaVM * jvm_, int model, int newParent){
350
351 JNIEnv * curEnv = NULL;
352 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
353 jclass cls = initClass(curEnv);
354 if ( cls == NULL) {
355 throw GiwsException::JniCallMethodException(curEnv);
356 }
357
358 static jmethodID voidcloneMenusjintintjintintID = curEnv->GetStaticMethodID(cls, "cloneMenus", "(II)V" ) ;
359 if (voidcloneMenusjintintjintintID == NULL) {
360 throw GiwsException::JniMethodNotFoundException(curEnv, "cloneMenus");
361 }
362
363                          curEnv->CallStaticVoidMethod(cls, voidcloneMenusjintintjintintID ,model, newParent);
364                         if (curEnv->ExceptionCheck()) {
365 throw GiwsException::JniCallMethodException(curEnv);
366 }
367 }
368
369 int Builder::cloneAxesModel (JavaVM * jvm_, int parent){
370
371 JNIEnv * curEnv = NULL;
372 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
373 jclass cls = initClass(curEnv);
374 if ( cls == NULL) {
375 throw GiwsException::JniCallMethodException(curEnv);
376 }
377
378 static jmethodID jintcloneAxesModeljintintID = curEnv->GetStaticMethodID(cls, "cloneAxesModel", "(I)I" ) ;
379 if (jintcloneAxesModeljintintID == NULL) {
380 throw GiwsException::JniMethodNotFoundException(curEnv, "cloneAxesModel");
381 }
382
383                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcloneAxesModeljintintID ,parent));
384                         if (curEnv->ExceptionCheck()) {
385 throw GiwsException::JniCallMethodException(curEnv);
386 }
387 return res;
388
389 }
390
391 int Builder::createSubWin (JavaVM * jvm_, int parent){
392
393 JNIEnv * curEnv = NULL;
394 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
395 jclass cls = initClass(curEnv);
396 if ( cls == NULL) {
397 throw GiwsException::JniCallMethodException(curEnv);
398 }
399
400 static jmethodID jintcreateSubWinjintintID = curEnv->GetStaticMethodID(cls, "createSubWin", "(I)I" ) ;
401 if (jintcreateSubWinjintintID == NULL) {
402 throw GiwsException::JniMethodNotFoundException(curEnv, "createSubWin");
403 }
404
405                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateSubWinjintintID ,parent));
406                         if (curEnv->ExceptionCheck()) {
407 throw GiwsException::JniCallMethodException(curEnv);
408 }
409 return res;
410
411 }
412
413 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){
414
415 JNIEnv * curEnv = NULL;
416 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
417 jclass cls = initClass(curEnv);
418 if ( cls == NULL) {
419 throw GiwsException::JniCallMethodException(curEnv);
420 }
421
422 static jmethodID jintcreateTextjintintjobjectArray_java_lang_Stringjava_lang_StringjintintjintintjdoubledoublejdoubledoublejbooleanbooleanjdoubleArray_doubledoublejintintjintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "createText", "(I[Ljava/lang/String;IIDDZ[DIIZIZZZZI)I" ) ;
423 if (jintcreateTextjintintjobjectArray_java_lang_Stringjava_lang_StringjintintjintintjdoubledoublejdoubledoublejbooleanbooleanjdoubleArray_doubledoublejintintjintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanjintintID == NULL) {
424 throw GiwsException::JniMethodNotFoundException(curEnv, "createText");
425 }
426 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
427
428 // create java array of strings.
429 jobjectArray text_ = curEnv->NewObjectArray( textSize, stringArrayClass, NULL);
430 if (text_ == NULL)
431 {
432 throw GiwsException::JniBadAllocException(curEnv);
433 }
434
435 // convert each char * to java strings and fill the java array.
436 for ( int i = 0; i < textSize; i++)
437 {
438 jstring TempString = curEnv->NewStringUTF( text[i] );
439 if (TempString == NULL)
440 {
441 throw GiwsException::JniBadAllocException(curEnv);
442 }
443
444 curEnv->SetObjectArrayElement( text_, i, TempString);
445
446 // avoid keeping reference on too many strings
447 curEnv->DeleteLocalRef(TempString);
448 }
449 jboolean autoSize_ = (static_cast<bool>(autoSize) ? JNI_TRUE : JNI_FALSE);
450
451 jdoubleArray userSize_ = curEnv->NewDoubleArray( userSizeSize ) ;
452
453 if (userSize_ == NULL)
454 {
455 // check that allocation succeed
456 throw GiwsException::JniBadAllocException(curEnv);
457 }
458
459 curEnv->SetDoubleArrayRegion( userSize_, 0, userSizeSize, (jdouble*)(userSize) ) ;
460
461
462 jboolean isForeground_ = (static_cast<bool>(isForeground) ? JNI_TRUE : JNI_FALSE);
463
464 jboolean isBackground_ = (static_cast<bool>(isBackground) ? JNI_TRUE : JNI_FALSE);
465
466 jboolean boxed_ = (static_cast<bool>(boxed) ? JNI_TRUE : JNI_FALSE);
467
468 jboolean line_ = (static_cast<bool>(line) ? JNI_TRUE : JNI_FALSE);
469
470 jboolean filled_ = (static_cast<bool>(filled) ? JNI_TRUE : JNI_FALSE);
471
472                         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));
473                         curEnv->DeleteLocalRef(stringArrayClass);
474 curEnv->DeleteLocalRef(text_);
475 curEnv->DeleteLocalRef(userSize_);
476 if (curEnv->ExceptionCheck()) {
477 throw GiwsException::JniCallMethodException(curEnv);
478 }
479 return res;
480
481 }
482
483 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){
484
485 JNIEnv * curEnv = NULL;
486 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
487 jclass cls = initClass(curEnv);
488 if ( cls == NULL) {
489 throw GiwsException::JniCallMethodException(curEnv);
490 }
491
492 static jmethodID jintcreateArcjintintjdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "createArc", "(IDDDDDDIZIZZZ)I" ) ;
493 if (jintcreateArcjintintjdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanID == NULL) {
494 throw GiwsException::JniMethodNotFoundException(curEnv, "createArc");
495 }
496
497 jboolean isForeground_ = (static_cast<bool>(isForeground) ? JNI_TRUE : JNI_FALSE);
498
499 jboolean isBackground_ = (static_cast<bool>(isBackground) ? JNI_TRUE : JNI_FALSE);
500
501 jboolean filled_ = (static_cast<bool>(filled) ? JNI_TRUE : JNI_FALSE);
502
503 jboolean line_ = (static_cast<bool>(line) ? JNI_TRUE : JNI_FALSE);
504
505                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateArcjintintjdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejdoubledoublejintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanID ,parent, x, y, h, w, start, end, foreground, isForeground_, background, isBackground_, filled_, line_));
506                         if (curEnv->ExceptionCheck()) {
507 throw GiwsException::JniCallMethodException(curEnv);
508 }
509 return res;
510
511 }
512
513 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){
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 jintcreateAxisjintintjintintjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintjstringjava_lang_StringjintintjintintjintintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "createAxis", "(III[D[DILjava/lang/String;IIIZ)I" ) ;
523 if (jintcreateAxisjintintjintintjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintjstringjava_lang_StringjintintjintintjintintjbooleanbooleanID == NULL) {
524 throw GiwsException::JniMethodNotFoundException(curEnv, "createAxis");
525 }
526
527 jdoubleArray vx_ = curEnv->NewDoubleArray( vxSize ) ;
528
529 if (vx_ == NULL)
530 {
531 // check that allocation succeed
532 throw GiwsException::JniBadAllocException(curEnv);
533 }
534
535 curEnv->SetDoubleArrayRegion( vx_, 0, vxSize, (jdouble*)(vx) ) ;
536
537
538 jdoubleArray vy_ = curEnv->NewDoubleArray( vySize ) ;
539
540 if (vy_ == NULL)
541 {
542 // check that allocation succeed
543 throw GiwsException::JniBadAllocException(curEnv);
544 }
545
546 curEnv->SetDoubleArrayRegion( vy_, 0, vySize, (jdouble*)(vy) ) ;
547
548
549 jstring format_ = curEnv->NewStringUTF( format );
550 if (format != NULL && format_ == NULL)
551 {
552 throw GiwsException::JniBadAllocException(curEnv);
553 }
554
555
556 jboolean seg_ = (static_cast<bool>(seg) ? JNI_TRUE : JNI_FALSE);
557
558                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateAxisjintintjintintjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintjstringjava_lang_StringjintintjintintjintintjbooleanbooleanID ,parent, dir, tics, vx_, vy_, subint, format_, fontSize, textColor, ticsColor, seg_));
559                         curEnv->DeleteLocalRef(vx_);
560 curEnv->DeleteLocalRef(vy_);
561 curEnv->DeleteLocalRef(format_);
562 if (curEnv->ExceptionCheck()) {
563 throw GiwsException::JniCallMethodException(curEnv);
564 }
565 return res;
566
567 }
568
569 int Builder::createCompound (JavaVM * jvm_, int parent, int const* children, int childrenSize){
570
571 JNIEnv * curEnv = NULL;
572 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
573 jclass cls = initClass(curEnv);
574 if ( cls == NULL) {
575 throw GiwsException::JniCallMethodException(curEnv);
576 }
577
578 static jmethodID jintcreateCompoundjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "createCompound", "(I[I)I" ) ;
579 if (jintcreateCompoundjintintjintArray_intintID == NULL) {
580 throw GiwsException::JniMethodNotFoundException(curEnv, "createCompound");
581 }
582
583 jintArray children_ = curEnv->NewIntArray( childrenSize ) ;
584
585 if (children_ == NULL)
586 {
587 // check that allocation succeed
588 throw GiwsException::JniBadAllocException(curEnv);
589 }
590
591 curEnv->SetIntArrayRegion( children_, 0, childrenSize, (jint*)(children) ) ;
592
593
594                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateCompoundjintintjintArray_intintID ,parent, children_));
595                         curEnv->DeleteLocalRef(children_);
596 if (curEnv->ExceptionCheck()) {
597 throw GiwsException::JniCallMethodException(curEnv);
598 }
599 return res;
600
601 }
602
603 int Builder::createCompoundSeq (JavaVM * jvm_, int parent, int childrenCount){
604
605 JNIEnv * curEnv = NULL;
606 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
607 jclass cls = initClass(curEnv);
608 if ( cls == NULL) {
609 throw GiwsException::JniCallMethodException(curEnv);
610 }
611
612 static jmethodID jintcreateCompoundSeqjintintjintintID = curEnv->GetStaticMethodID(cls, "createCompoundSeq", "(II)I" ) ;
613 if (jintcreateCompoundSeqjintintjintintID == NULL) {
614 throw GiwsException::JniMethodNotFoundException(curEnv, "createCompoundSeq");
615 }
616
617                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateCompoundSeqjintintjintintID ,parent, childrenCount));
618                         if (curEnv->ExceptionCheck()) {
619 throw GiwsException::JniCallMethodException(curEnv);
620 }
621 return res;
622
623 }
624
625 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){
626
627 JNIEnv * curEnv = NULL;
628 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
629 jclass cls = initClass(curEnv);
630 if ( cls == NULL) {
631 throw GiwsException::JniCallMethodException(curEnv);
632 }
633
634 static jmethodID jintcreateFecjintintjdoubleArray_doubledoublejintArray_intintjintArray_intintjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "createFec", "(I[D[I[IZ)I" ) ;
635 if (jintcreateFecjintintjdoubleArray_doubledoublejintArray_intintjintArray_intintjbooleanbooleanID == NULL) {
636 throw GiwsException::JniMethodNotFoundException(curEnv, "createFec");
637 }
638
639 jdoubleArray zminmax_ = curEnv->NewDoubleArray( zminmaxSize ) ;
640
641 if (zminmax_ == NULL)
642 {
643 // check that allocation succeed
644 throw GiwsException::JniBadAllocException(curEnv);
645 }
646
647 curEnv->SetDoubleArrayRegion( zminmax_, 0, zminmaxSize, (jdouble*)(zminmax) ) ;
648
649
650 jintArray colminmax_ = curEnv->NewIntArray( colminmaxSize ) ;
651
652 if (colminmax_ == NULL)
653 {
654 // check that allocation succeed
655 throw GiwsException::JniBadAllocException(curEnv);
656 }
657
658 curEnv->SetIntArrayRegion( colminmax_, 0, colminmaxSize, (jint*)(colminmax) ) ;
659
660
661 jintArray colout_ = curEnv->NewIntArray( coloutSize ) ;
662
663 if (colout_ == NULL)
664 {
665 // check that allocation succeed
666 throw GiwsException::JniBadAllocException(curEnv);
667 }
668
669 curEnv->SetIntArrayRegion( colout_, 0, coloutSize, (jint*)(colout) ) ;
670
671
672 jboolean with_mesh_ = (static_cast<bool>(with_mesh) ? JNI_TRUE : JNI_FALSE);
673
674                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateFecjintintjdoubleArray_doubledoublejintArray_intintjintArray_intintjbooleanbooleanID ,parent, zminmax_, colminmax_, colout_, with_mesh_));
675                         curEnv->DeleteLocalRef(zminmax_);
676 curEnv->DeleteLocalRef(colminmax_);
677 curEnv->DeleteLocalRef(colout_);
678 if (curEnv->ExceptionCheck()) {
679 throw GiwsException::JniCallMethodException(curEnv);
680 }
681 return res;
682
683 }
684
685 int Builder::createGrayplot (JavaVM * jvm_, int parent, int type, double const* pvecx, int pvecxSize, int n1, int n2){
686
687 JNIEnv * curEnv = NULL;
688 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
689 jclass cls = initClass(curEnv);
690 if ( cls == NULL) {
691 throw GiwsException::JniCallMethodException(curEnv);
692 }
693
694 static jmethodID jintcreateGrayplotjintintjintintjdoubleArray_doubledoublejintintjintintID = curEnv->GetStaticMethodID(cls, "createGrayplot", "(II[DII)I" ) ;
695 if (jintcreateGrayplotjintintjintintjdoubleArray_doubledoublejintintjintintID == NULL) {
696 throw GiwsException::JniMethodNotFoundException(curEnv, "createGrayplot");
697 }
698
699 jdoubleArray pvecx_ = curEnv->NewDoubleArray( pvecxSize ) ;
700
701 if (pvecx_ == NULL)
702 {
703 // check that allocation succeed
704 throw GiwsException::JniBadAllocException(curEnv);
705 }
706
707 curEnv->SetDoubleArrayRegion( pvecx_, 0, pvecxSize, (jdouble*)(pvecx) ) ;
708
709
710                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateGrayplotjintintjintintjdoubleArray_doubledoublejintintjintintID ,parent, type, pvecx_, n1, n2));
711                         curEnv->DeleteLocalRef(pvecx_);
712 if (curEnv->ExceptionCheck()) {
713 throw GiwsException::JniCallMethodException(curEnv);
714 }
715 return res;
716
717 }
718
719 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){
720
721 JNIEnv * curEnv = NULL;
722 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
723 jclass cls = initClass(curEnv);
724 if ( cls == NULL) {
725 throw GiwsException::JniCallMethodException(curEnv);
726 }
727
728 static jmethodID jintcreatePolylinejintintjbooleanbooleanjintintjintintjbooleanbooleanjintArray_intintjintintjbooleanbooleanjintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "createPolyline", "(IZIIZ[IIZIZIZZZZZ)I" ) ;
729 if (jintcreatePolylinejintintjbooleanbooleanjintintjintintjbooleanbooleanjintArray_intintjintintjbooleanbooleanjintintjbooleanbooleanjintintjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanjbooleanbooleanID == NULL) {
730 throw GiwsException::JniMethodNotFoundException(curEnv, "createPolyline");
731 }
732
733 jboolean closed_ = (static_cast<bool>(closed) ? JNI_TRUE : JNI_FALSE);
734
735 jboolean isForeground_ = (static_cast<bool>(isForeground) ? JNI_TRUE : JNI_FALSE);
736
737 jintArray background_ = curEnv->NewIntArray( backgroundSize ) ;
738
739 if (background_ == NULL)
740 {
741 // check that allocation succeed
742 throw GiwsException::JniBadAllocException(curEnv);
743 }
744
745 curEnv->SetIntArrayRegion( background_, 0, backgroundSize, (jint*)(background) ) ;
746
747
748 jboolean isMarkStyle_ = (static_cast<bool>(isMarkStyle) ? JNI_TRUE : JNI_FALSE);
749
750 jboolean isMarkForeground_ = (static_cast<bool>(isMarkForeground) ? JNI_TRUE : JNI_FALSE);
751
752 jboolean isMarkBackground_ = (static_cast<bool>(isMarkBackground) ? JNI_TRUE : JNI_FALSE);
753
754 jboolean isline_ = (static_cast<bool>(isline) ? JNI_TRUE : JNI_FALSE);
755
756 jboolean isfilled_ = (static_cast<bool>(isfilled) ? JNI_TRUE : JNI_FALSE);
757
758 jboolean ismark_ = (static_cast<bool>(ismark) ? JNI_TRUE : JNI_FALSE);
759
760 jboolean isinterp_ = (static_cast<bool>(isinterp) ? JNI_TRUE : JNI_FALSE);
761
762                         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_));
763                         curEnv->DeleteLocalRef(background_);
764 if (curEnv->ExceptionCheck()) {
765 throw GiwsException::JniCallMethodException(curEnv);
766 }
767 return res;
768
769 }
770
771 int Builder::createLegend (JavaVM * jvm_, int parent, char const* const* text, int textSize, int const* handles, int handlesSize){
772
773 JNIEnv * curEnv = NULL;
774 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
775 jclass cls = initClass(curEnv);
776 if ( cls == NULL) {
777 throw GiwsException::JniCallMethodException(curEnv);
778 }
779
780 static jmethodID jintcreateLegendjintintjobjectArray_java_lang_Stringjava_lang_StringjintArray_intintID = curEnv->GetStaticMethodID(cls, "createLegend", "(I[Ljava/lang/String;[I)I" ) ;
781 if (jintcreateLegendjintintjobjectArray_java_lang_Stringjava_lang_StringjintArray_intintID == NULL) {
782 throw GiwsException::JniMethodNotFoundException(curEnv, "createLegend");
783 }
784 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
785
786 // create java array of strings.
787 jobjectArray text_ = curEnv->NewObjectArray( textSize, stringArrayClass, NULL);
788 if (text_ == NULL)
789 {
790 throw GiwsException::JniBadAllocException(curEnv);
791 }
792
793 // convert each char * to java strings and fill the java array.
794 for ( int i = 0; i < textSize; i++)
795 {
796 jstring TempString = curEnv->NewStringUTF( text[i] );
797 if (TempString == NULL)
798 {
799 throw GiwsException::JniBadAllocException(curEnv);
800 }
801
802 curEnv->SetObjectArrayElement( text_, i, TempString);
803
804 // avoid keeping reference on too many strings
805 curEnv->DeleteLocalRef(TempString);
806 }
807 jintArray handles_ = curEnv->NewIntArray( handlesSize ) ;
808
809 if (handles_ == NULL)
810 {
811 // check that allocation succeed
812 throw GiwsException::JniBadAllocException(curEnv);
813 }
814
815 curEnv->SetIntArrayRegion( handles_, 0, handlesSize, (jint*)(handles) ) ;
816
817
818                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateLegendjintintjobjectArray_java_lang_Stringjava_lang_StringjintArray_intintID ,parent, text_, handles_));
819                         curEnv->DeleteLocalRef(stringArrayClass);
820 curEnv->DeleteLocalRef(text_);
821 curEnv->DeleteLocalRef(handles_);
822 if (curEnv->ExceptionCheck()) {
823 throw GiwsException::JniCallMethodException(curEnv);
824 }
825 return res;
826
827 }
828
829 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){
830
831 JNIEnv * curEnv = NULL;
832 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
833 jclass cls = initClass(curEnv);
834 if ( cls == NULL) {
835 throw GiwsException::JniCallMethodException(curEnv);
836 }
837
838 static jmethodID jintcreateSegsjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejbooleanbooleanjintArray_intintjdoubledoubleID = curEnv->GetStaticMethodID(cls, "createSegs", "(I[D[D[DZ[ID)I" ) ;
839 if (jintcreateSegsjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejbooleanbooleanjintArray_intintjdoubledoubleID == NULL) {
840 throw GiwsException::JniMethodNotFoundException(curEnv, "createSegs");
841 }
842
843 jdoubleArray vx_ = curEnv->NewDoubleArray( vxSize ) ;
844
845 if (vx_ == NULL)
846 {
847 // check that allocation succeed
848 throw GiwsException::JniBadAllocException(curEnv);
849 }
850
851 curEnv->SetDoubleArrayRegion( vx_, 0, vxSize, (jdouble*)(vx) ) ;
852
853
854 jdoubleArray vy_ = curEnv->NewDoubleArray( vySize ) ;
855
856 if (vy_ == NULL)
857 {
858 // check that allocation succeed
859 throw GiwsException::JniBadAllocException(curEnv);
860 }
861
862 curEnv->SetDoubleArrayRegion( vy_, 0, vySize, (jdouble*)(vy) ) ;
863
864
865 jdoubleArray vz_ = curEnv->NewDoubleArray( vzSize ) ;
866
867 if (vz_ == NULL)
868 {
869 // check that allocation succeed
870 throw GiwsException::JniBadAllocException(curEnv);
871 }
872
873 curEnv->SetDoubleArrayRegion( vz_, 0, vzSize, (jdouble*)(vz) ) ;
874
875
876 jboolean isVZ_ = (static_cast<bool>(isVZ) ? JNI_TRUE : JNI_FALSE);
877
878 jintArray style_ = curEnv->NewIntArray( styleSize ) ;
879
880 if (style_ == NULL)
881 {
882 // check that allocation succeed
883 throw GiwsException::JniBadAllocException(curEnv);
884 }
885
886 curEnv->SetIntArrayRegion( style_, 0, styleSize, (jint*)(style) ) ;
887
888
889                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateSegsjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejbooleanbooleanjintArray_intintjdoubledoubleID ,parent, vx_, vy_, vz_, isVZ_, style_, arsize));
890                         curEnv->DeleteLocalRef(vx_);
891 curEnv->DeleteLocalRef(vy_);
892 curEnv->DeleteLocalRef(vz_);
893 curEnv->DeleteLocalRef(style_);
894 if (curEnv->ExceptionCheck()) {
895 throw GiwsException::JniCallMethodException(curEnv);
896 }
897 return res;
898
899 }
900
901 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){
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 jintcreateChampjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubledoublejbooleanbooleanID = curEnv->GetStaticMethodID(cls, "createChamp", "(I[D[D[D[DDZ)I" ) ;
911 if (jintcreateChampjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubledoublejbooleanbooleanID == NULL) {
912 throw GiwsException::JniMethodNotFoundException(curEnv, "createChamp");
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 vfx_ = curEnv->NewDoubleArray( vfxSize ) ;
938
939 if (vfx_ == NULL)
940 {
941 // check that allocation succeed
942 throw GiwsException::JniBadAllocException(curEnv);
943 }
944
945 curEnv->SetDoubleArrayRegion( vfx_, 0, vfxSize, (jdouble*)(vfx) ) ;
946
947
948 jdoubleArray vfy_ = curEnv->NewDoubleArray( vfySize ) ;
949
950 if (vfy_ == NULL)
951 {
952 // check that allocation succeed
953 throw GiwsException::JniBadAllocException(curEnv);
954 }
955
956 curEnv->SetDoubleArrayRegion( vfy_, 0, vfySize, (jdouble*)(vfy) ) ;
957
958
959 jboolean typeofchamp_ = (static_cast<bool>(typeofchamp) ? JNI_TRUE : JNI_FALSE);
960
961                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateChampjintintjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubledoublejbooleanbooleanID ,parent, vx_, vy_, vfx_, vfy_, arsize, typeofchamp_));
962                         curEnv->DeleteLocalRef(vx_);
963 curEnv->DeleteLocalRef(vy_);
964 curEnv->DeleteLocalRef(vfx_);
965 curEnv->DeleteLocalRef(vfy_);
966 if (curEnv->ExceptionCheck()) {
967 throw GiwsException::JniCallMethodException(curEnv);
968 }
969 return res;
970
971 }
972
973 int Builder::createSurface (JavaVM * jvm_, int parent, int typeof3d, int colorFlag, int colorMode){
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 jintcreateSurfacejintintjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "createSurface", "(IIII)I" ) ;
983 if (jintcreateSurfacejintintjintintjintintjintintID == NULL) {
984 throw GiwsException::JniMethodNotFoundException(curEnv, "createSurface");
985 }
986
987                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateSurfacejintintjintintjintintjintintID ,parent, typeof3d, colorFlag, colorMode));
988                         if (curEnv->ExceptionCheck()) {
989 throw GiwsException::JniCallMethodException(curEnv);
990 }
991 return res;
992
993 }
994
995 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){
996
997 JNIEnv * curEnv = NULL;
998 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
999 jclass cls = initClass(curEnv);
1000 if ( cls == NULL) {
1001 throw GiwsException::JniCallMethodException(curEnv);
1002 }
1003
1004 static jmethodID voidinitSubWinTo3djintintjstringjava_lang_StringjbooleanbooleanjintArray_intintjdoubledoublejdoubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID = curEnv->GetStaticMethodID(cls, "initSubWinTo3d", "(ILjava/lang/String;Z[IDD[D[D[D[D)V" ) ;
1005 if (voidinitSubWinTo3djintintjstringjava_lang_StringjbooleanbooleanjintArray_intintjdoubledoublejdoubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID == NULL) {
1006 throw GiwsException::JniMethodNotFoundException(curEnv, "initSubWinTo3d");
1007 }
1008
1009 jstring legend_ = curEnv->NewStringUTF( legend );
1010 if (legend != NULL && legend_ == NULL)
1011 {
1012 throw GiwsException::JniBadAllocException(curEnv);
1013 }
1014
1015
1016 jboolean isLegend_ = (static_cast<bool>(isLegend) ? JNI_TRUE : JNI_FALSE);
1017
1018 jintArray flag_ = curEnv->NewIntArray( flagSize ) ;
1019
1020 if (flag_ == NULL)
1021 {
1022 // check that allocation succeed
1023 throw GiwsException::JniBadAllocException(curEnv);
1024 }
1025
1026 curEnv->SetIntArrayRegion( flag_, 0, flagSize, (jint*)(flag) ) ;
1027
1028
1029 jdoubleArray ebox_ = curEnv->NewDoubleArray( eboxSize ) ;
1030
1031 if (ebox_ == NULL)
1032 {
1033 // check that allocation succeed
1034 throw GiwsException::JniBadAllocException(curEnv);
1035 }
1036
1037 curEnv->SetDoubleArrayRegion( ebox_, 0, eboxSize, (jdouble*)(ebox) ) ;
1038
1039
1040 jdoubleArray x_ = curEnv->NewDoubleArray( xSize ) ;
1041
1042 if (x_ == NULL)
1043 {
1044 // check that allocation succeed
1045 throw GiwsException::JniBadAllocException(curEnv);
1046 }
1047
1048 curEnv->SetDoubleArrayRegion( x_, 0, xSize, (jdouble*)(x) ) ;
1049
1050
1051 jdoubleArray y_ = curEnv->NewDoubleArray( ySize ) ;
1052
1053 if (y_ == NULL)
1054 {
1055 // check that allocation succeed
1056 throw GiwsException::JniBadAllocException(curEnv);
1057 }
1058
1059 curEnv->SetDoubleArrayRegion( y_, 0, ySize, (jdouble*)(y) ) ;
1060
1061
1062 jdoubleArray z_ = curEnv->NewDoubleArray( zSize ) ;
1063
1064 if (z_ == NULL)
1065 {
1066 // check that allocation succeed
1067 throw GiwsException::JniBadAllocException(curEnv);
1068 }
1069
1070 curEnv->SetDoubleArrayRegion( z_, 0, zSize, (jdouble*)(z) ) ;
1071
1072
1073                          curEnv->CallStaticVoidMethod(cls, voidinitSubWinTo3djintintjstringjava_lang_StringjbooleanbooleanjintArray_intintjdoubledoublejdoubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID ,parent, legend_, isLegend_, flag_, alpha, theta, ebox_, x_, y_, z_);
1074                         curEnv->DeleteLocalRef(legend_);
1075 curEnv->DeleteLocalRef(flag_);
1076 curEnv->DeleteLocalRef(ebox_);
1077 curEnv->DeleteLocalRef(x_);
1078 curEnv->DeleteLocalRef(y_);
1079 curEnv->DeleteLocalRef(z_);
1080 if (curEnv->ExceptionCheck()) {
1081 throw GiwsException::JniCallMethodException(curEnv);
1082 }
1083 }
1084
1085 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){
1086
1087 JNIEnv * curEnv = NULL;
1088 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1089 jclass cls = initClass(curEnv);
1090 if ( cls == NULL) {
1091 throw GiwsException::JniCallMethodException(curEnv);
1092 }
1093
1094 static jmethodID jintcreateLightjintintjintintjbooleanbooleanjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID = curEnv->GetStaticMethodID(cls, "createLight", "(IIZ[D[D[D[D[D)I" ) ;
1095 if (jintcreateLightjintintjintintjbooleanbooleanjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID == NULL) {
1096 throw GiwsException::JniMethodNotFoundException(curEnv, "createLight");
1097 }
1098
1099 jboolean visible_ = (static_cast<bool>(visible) ? JNI_TRUE : JNI_FALSE);
1100
1101 jdoubleArray pos_ = curEnv->NewDoubleArray( posSize ) ;
1102
1103 if (pos_ == NULL)
1104 {
1105 // check that allocation succeed
1106 throw GiwsException::JniBadAllocException(curEnv);
1107 }
1108
1109 curEnv->SetDoubleArrayRegion( pos_, 0, posSize, (jdouble*)(pos) ) ;
1110
1111
1112 jdoubleArray dir_ = curEnv->NewDoubleArray( dirSize ) ;
1113
1114 if (dir_ == NULL)
1115 {
1116 // check that allocation succeed
1117 throw GiwsException::JniBadAllocException(curEnv);
1118 }
1119
1120 curEnv->SetDoubleArrayRegion( dir_, 0, dirSize, (jdouble*)(dir) ) ;
1121
1122
1123 jdoubleArray ambient_ = curEnv->NewDoubleArray( ambientSize ) ;
1124
1125 if (ambient_ == NULL)
1126 {
1127 // check that allocation succeed
1128 throw GiwsException::JniBadAllocException(curEnv);
1129 }
1130
1131 curEnv->SetDoubleArrayRegion( ambient_, 0, ambientSize, (jdouble*)(ambient) ) ;
1132
1133
1134 jdoubleArray diffuse_ = curEnv->NewDoubleArray( diffuseSize ) ;
1135
1136 if (diffuse_ == NULL)
1137 {
1138 // check that allocation succeed
1139 throw GiwsException::JniBadAllocException(curEnv);
1140 }
1141
1142 curEnv->SetDoubleArrayRegion( diffuse_, 0, diffuseSize, (jdouble*)(diffuse) ) ;
1143
1144
1145 jdoubleArray specular_ = curEnv->NewDoubleArray( specularSize ) ;
1146
1147 if (specular_ == NULL)
1148 {
1149 // check that allocation succeed
1150 throw GiwsException::JniBadAllocException(curEnv);
1151 }
1152
1153 curEnv->SetDoubleArrayRegion( specular_, 0, specularSize, (jdouble*)(specular) ) ;
1154
1155
1156                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateLightjintintjintintjbooleanbooleanjdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoublejdoubleArray_doubledoubleID ,parent, type, visible_, pos_, dir_, ambient_, diffuse_, specular_));
1157                         curEnv->DeleteLocalRef(pos_);
1158 curEnv->DeleteLocalRef(dir_);
1159 curEnv->DeleteLocalRef(ambient_);
1160 curEnv->DeleteLocalRef(diffuse_);
1161 curEnv->DeleteLocalRef(specular_);
1162 if (curEnv->ExceptionCheck()) {
1163 throw GiwsException::JniCallMethodException(curEnv);
1164 }
1165 return res;
1166
1167 }
1168
1169 }