aa1d30b3a843ad35615545d5d7f7b014ce826f95
[scilab.git] / scilab / modules / graphic_export / src / jni / GL2PSToJOGL.cpp
1 #include "GL2PSToJOGL.hxx"
2 /* Generated by GIWS (version 1.2.4) */
3 /*
4
5 Copyright 2007-2008 INRIA
6 Copyright 2008-2011 DIGITEO
7
8 Author : Sylvestre Ledru & others
9
10 This is generated code.
11
12 This software is a computer program whose purpose is to hide the complexity
13 of accessing Java objects/methods from C++ code.
14
15 This software is governed by the CeCILL-B license under French law and
16 abiding by the rules of distribution of free software.  You can  use, 
17 modify and/ or redistribute the software under the terms of the CeCILL-B
18 license as circulated by CEA, CNRS and INRIA at the following URL
19 "http://www.cecill.info". 
20
21 As a counterpart to the access to the source code and  rights to copy,
22 modify and redistribute granted by the license, users are provided only
23 with a limited warranty  and the software's author,  the holder of the
24 economic rights,  and the successive licensors  have only  limited
25 liability. 
26
27 In this respect, the user's attention is drawn to the risks associated
28 with loading,  using,  modifying and/or developing or reproducing the
29 software by the user in light of its specific status of free software,
30 that may mean  that it is complicated to manipulate,  and  that  also
31 therefore means  that it is reserved for developers  and  experienced
32 professionals having in-depth computer knowledge. Users are therefore
33 encouraged to load and test the software's suitability as regards their
34 requirements in conditions enabling the security of their systems and/or 
35 data to be ensured and,  more generally, to use and operate it in the 
36 same conditions as regards security. 
37
38 The fact that you are presently reading this means that you have had
39 knowledge of the CeCILL-B license and that you accept its terms.
40 */
41
42 namespace org_scilab_modules_graphic_export {
43
44 // Returns the current env
45
46 JNIEnv * GL2PSToJOGL::getCurrentEnv() {
47 JNIEnv * curEnv = NULL;
48 jint res=this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
49 if (res != JNI_OK) {
50 throw GiwsException::JniException(getCurrentEnv());
51 }
52 return curEnv;
53 }
54 // Destructor
55
56 GL2PSToJOGL::~GL2PSToJOGL() {
57 JNIEnv * curEnv = NULL;
58 this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
59
60 curEnv->DeleteGlobalRef(this->instance);
61 curEnv->DeleteGlobalRef(this->instanceClass);
62 }
63 // Constructors
64 GL2PSToJOGL::GL2PSToJOGL(JavaVM * jvm_) {
65 jmethodID constructObject = NULL ;
66 jobject localInstance ;
67 jclass localClass ;
68 const std::string construct="<init>";
69 const std::string param="()V";
70 jvm=jvm_;
71
72 JNIEnv * curEnv = getCurrentEnv();
73
74 localClass = curEnv->FindClass( this->className().c_str() ) ;
75 if (localClass == NULL) {
76   throw GiwsException::JniClassNotFoundException(curEnv, this->className());
77 }
78
79 this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
80
81 /* localClass is not needed anymore */
82 curEnv->DeleteLocalRef(localClass);
83
84 if (this->instanceClass == NULL) {
85 throw GiwsException::JniObjectCreationException(curEnv, this->className());
86 }
87
88
89 constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
90 if(constructObject == NULL){
91 throw GiwsException::JniObjectCreationException(curEnv, this->className());
92 }
93
94 localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
95 if(localInstance == NULL){
96 throw GiwsException::JniObjectCreationException(curEnv, this->className());
97 }
98  
99 this->instance = curEnv->NewGlobalRef(localInstance) ;
100 if(this->instance == NULL){
101 throw GiwsException::JniObjectCreationException(curEnv, this->className());
102 }
103 /* localInstance not needed anymore */
104 curEnv->DeleteLocalRef(localInstance);
105
106                 /* Methods ID set to NULL */
107 voidglFeedbackBufferjintjintID=NULL; 
108 jfloatArray_readFeedbackBufferjintID=NULL; 
109 jbooleanglIsEnabledjintID=NULL; 
110 voidglBeginjintID=NULL; 
111 voidglVertex3fjfloatjfloatjfloatID=NULL; 
112 voidglEndID=NULL; 
113 jbooleanglGetCurrentRasterPositionValidID=NULL; 
114 jintglRenderModejintID=NULL; 
115 jintglGetLineStipplePatternID=NULL; 
116 jintglGetLineStippleRepeatID=NULL; 
117 jintglGetIndexClearValueID=NULL; 
118 jintArray_glGetViewportID=NULL; 
119 jintglGetBlendSrcID=NULL; 
120 jintglGetBlendDstID=NULL; 
121 jfloatArray_glGetColorClearValueID=NULL; 
122 jfloatglGetPolygonOffsetFactorID=NULL; 
123 jfloatglGetPolygonOffsetUnitsID=NULL; 
124 jfloatArray_glGetCurrentRasterPositionID=NULL; 
125 jfloatArray_glGetCurrentRasterColorID=NULL; 
126 voidglPassThroughjfloatID=NULL; 
127
128
129 }
130
131 GL2PSToJOGL::GL2PSToJOGL(JavaVM * jvm_, jobject JObj) {
132         jvm=jvm_;
133
134         JNIEnv * curEnv = getCurrentEnv();
135
136 jclass localClass = curEnv->GetObjectClass(JObj);
137         this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
138         curEnv->DeleteLocalRef(localClass);
139
140         if (this->instanceClass == NULL) {
141 throw GiwsException::JniObjectCreationException(curEnv, this->className());
142         }
143
144         this->instance = curEnv->NewGlobalRef(JObj) ;
145         if(this->instance == NULL){
146 throw GiwsException::JniObjectCreationException(curEnv, this->className());
147         }
148         /* Methods ID set to NULL */
149         voidglFeedbackBufferjintjintID=NULL; 
150 jfloatArray_readFeedbackBufferjintID=NULL; 
151 jbooleanglIsEnabledjintID=NULL; 
152 voidglBeginjintID=NULL; 
153 voidglVertex3fjfloatjfloatjfloatID=NULL; 
154 voidglEndID=NULL; 
155 jbooleanglGetCurrentRasterPositionValidID=NULL; 
156 jintglRenderModejintID=NULL; 
157 jintglGetLineStipplePatternID=NULL; 
158 jintglGetLineStippleRepeatID=NULL; 
159 jintglGetIndexClearValueID=NULL; 
160 jintArray_glGetViewportID=NULL; 
161 jintglGetBlendSrcID=NULL; 
162 jintglGetBlendDstID=NULL; 
163 jfloatArray_glGetColorClearValueID=NULL; 
164 jfloatglGetPolygonOffsetFactorID=NULL; 
165 jfloatglGetPolygonOffsetUnitsID=NULL; 
166 jfloatArray_glGetCurrentRasterPositionID=NULL; 
167 jfloatArray_glGetCurrentRasterColorID=NULL; 
168 voidglPassThroughjfloatID=NULL; 
169
170
171 }
172
173 // Generic methods
174
175 void GL2PSToJOGL::synchronize() {
176 if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
177 throw GiwsException::JniMonitorException(getCurrentEnv(), "GL2PSToJOGL");
178 }
179 }
180
181 void GL2PSToJOGL::endSynchronize() {
182 if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
183 throw GiwsException::JniMonitorException(getCurrentEnv(), "GL2PSToJOGL");
184 }
185 }
186 // Method(s)
187
188 void GL2PSToJOGL::glFeedbackBuffer (JavaVM * jvm_, int arg0, int arg1){
189
190 JNIEnv * curEnv = NULL;
191 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
192 jclass cls = curEnv->FindClass( className().c_str() );
193
194 jmethodID voidglFeedbackBufferjintjintID = curEnv->GetStaticMethodID(cls, "glFeedbackBuffer", "(II)V" ) ;
195 if (voidglFeedbackBufferjintjintID == NULL) {
196 throw GiwsException::JniMethodNotFoundException(curEnv, "glFeedbackBuffer");
197 }
198
199                          curEnv->CallStaticVoidMethod(cls, voidglFeedbackBufferjintjintID ,arg0, arg1);
200                         curEnv->DeleteLocalRef(cls);
201 if (curEnv->ExceptionCheck()) {
202 throw GiwsException::JniCallMethodException(curEnv);
203 }
204 }
205
206 float* GL2PSToJOGL::readFeedbackBuffer (JavaVM * jvm_, int size){
207
208 JNIEnv * curEnv = NULL;
209 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
210 jclass cls = curEnv->FindClass( className().c_str() );
211
212 jmethodID jfloatArray_readFeedbackBufferjintID = curEnv->GetStaticMethodID(cls, "readFeedbackBuffer", "(I)[F" ) ;
213 if (jfloatArray_readFeedbackBufferjintID == NULL) {
214 throw GiwsException::JniMethodNotFoundException(curEnv, "readFeedbackBuffer");
215 }
216
217                         jfloatArray res =  static_cast<jfloatArray>( curEnv->CallStaticObjectMethod(cls, jfloatArray_readFeedbackBufferjintID ,size));
218                         if (res == NULL) { return NULL; }
219                         if (curEnv->ExceptionCheck()) {
220 throw GiwsException::JniCallMethodException(curEnv);
221 }int lenRow;
222  lenRow = curEnv->GetArrayLength(res);
223 jboolean isCopy = JNI_FALSE;
224
225 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
226 jfloat *resultsArray = static_cast<jfloat *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
227 float* myArray= new float[ lenRow];
228
229 for (jsize i = 0; i <  lenRow; i++){
230 myArray[i]=resultsArray[i];
231 }
232 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
233
234                         curEnv->DeleteLocalRef(res);
235 curEnv->DeleteLocalRef(cls);
236 if (curEnv->ExceptionCheck()) {
237 delete[] myArray;
238                                 throw GiwsException::JniCallMethodException(curEnv);
239 }
240 return myArray;
241
242 }
243
244 bool GL2PSToJOGL::glIsEnabled (JavaVM * jvm_, int arg0){
245
246 JNIEnv * curEnv = NULL;
247 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
248 jclass cls = curEnv->FindClass( className().c_str() );
249
250 jmethodID jbooleanglIsEnabledjintID = curEnv->GetStaticMethodID(cls, "glIsEnabled", "(I)Z" ) ;
251 if (jbooleanglIsEnabledjintID == NULL) {
252 throw GiwsException::JniMethodNotFoundException(curEnv, "glIsEnabled");
253 }
254
255                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanglIsEnabledjintID ,arg0));
256                         curEnv->DeleteLocalRef(cls);
257 if (curEnv->ExceptionCheck()) {
258 throw GiwsException::JniCallMethodException(curEnv);
259 }
260 return (res == JNI_TRUE);
261
262 }
263
264 void GL2PSToJOGL::glBegin (JavaVM * jvm_, int arg0){
265
266 JNIEnv * curEnv = NULL;
267 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
268 jclass cls = curEnv->FindClass( className().c_str() );
269
270 jmethodID voidglBeginjintID = curEnv->GetStaticMethodID(cls, "glBegin", "(I)V" ) ;
271 if (voidglBeginjintID == NULL) {
272 throw GiwsException::JniMethodNotFoundException(curEnv, "glBegin");
273 }
274
275                          curEnv->CallStaticVoidMethod(cls, voidglBeginjintID ,arg0);
276                         curEnv->DeleteLocalRef(cls);
277 if (curEnv->ExceptionCheck()) {
278 throw GiwsException::JniCallMethodException(curEnv);
279 }
280 }
281
282 void GL2PSToJOGL::glVertex3f (JavaVM * jvm_, float arg0, float arg1, float arg2){
283
284 JNIEnv * curEnv = NULL;
285 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
286 jclass cls = curEnv->FindClass( className().c_str() );
287
288 jmethodID voidglVertex3fjfloatjfloatjfloatID = curEnv->GetStaticMethodID(cls, "glVertex3f", "(FFF)V" ) ;
289 if (voidglVertex3fjfloatjfloatjfloatID == NULL) {
290 throw GiwsException::JniMethodNotFoundException(curEnv, "glVertex3f");
291 }
292
293                          curEnv->CallStaticVoidMethod(cls, voidglVertex3fjfloatjfloatjfloatID ,arg0, arg1, arg2);
294                         curEnv->DeleteLocalRef(cls);
295 if (curEnv->ExceptionCheck()) {
296 throw GiwsException::JniCallMethodException(curEnv);
297 }
298 }
299
300 void GL2PSToJOGL::glEnd (JavaVM * jvm_){
301
302 JNIEnv * curEnv = NULL;
303 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
304 jclass cls = curEnv->FindClass( className().c_str() );
305
306 jmethodID voidglEndID = curEnv->GetStaticMethodID(cls, "glEnd", "()V" ) ;
307 if (voidglEndID == NULL) {
308 throw GiwsException::JniMethodNotFoundException(curEnv, "glEnd");
309 }
310
311                          curEnv->CallStaticVoidMethod(cls, voidglEndID );
312                         curEnv->DeleteLocalRef(cls);
313 if (curEnv->ExceptionCheck()) {
314 throw GiwsException::JniCallMethodException(curEnv);
315 }
316 }
317
318 bool GL2PSToJOGL::glGetCurrentRasterPositionValid (JavaVM * jvm_){
319
320 JNIEnv * curEnv = NULL;
321 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
322 jclass cls = curEnv->FindClass( className().c_str() );
323
324 jmethodID jbooleanglGetCurrentRasterPositionValidID = curEnv->GetStaticMethodID(cls, "glGetCurrentRasterPositionValid", "()Z" ) ;
325 if (jbooleanglGetCurrentRasterPositionValidID == NULL) {
326 throw GiwsException::JniMethodNotFoundException(curEnv, "glGetCurrentRasterPositionValid");
327 }
328
329                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanglGetCurrentRasterPositionValidID ));
330                         curEnv->DeleteLocalRef(cls);
331 if (curEnv->ExceptionCheck()) {
332 throw GiwsException::JniCallMethodException(curEnv);
333 }
334 return (res == JNI_TRUE);
335
336 }
337
338 int GL2PSToJOGL::glRenderMode (JavaVM * jvm_, int arg0){
339
340 JNIEnv * curEnv = NULL;
341 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
342 jclass cls = curEnv->FindClass( className().c_str() );
343
344 jmethodID jintglRenderModejintID = curEnv->GetStaticMethodID(cls, "glRenderMode", "(I)I" ) ;
345 if (jintglRenderModejintID == NULL) {
346 throw GiwsException::JniMethodNotFoundException(curEnv, "glRenderMode");
347 }
348
349                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintglRenderModejintID ,arg0));
350                         curEnv->DeleteLocalRef(cls);
351 if (curEnv->ExceptionCheck()) {
352 throw GiwsException::JniCallMethodException(curEnv);
353 }
354 return res;
355
356 }
357
358 int GL2PSToJOGL::glGetLineStipplePattern (JavaVM * jvm_){
359
360 JNIEnv * curEnv = NULL;
361 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
362 jclass cls = curEnv->FindClass( className().c_str() );
363
364 jmethodID jintglGetLineStipplePatternID = curEnv->GetStaticMethodID(cls, "glGetLineStipplePattern", "()I" ) ;
365 if (jintglGetLineStipplePatternID == NULL) {
366 throw GiwsException::JniMethodNotFoundException(curEnv, "glGetLineStipplePattern");
367 }
368
369                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintglGetLineStipplePatternID ));
370                         curEnv->DeleteLocalRef(cls);
371 if (curEnv->ExceptionCheck()) {
372 throw GiwsException::JniCallMethodException(curEnv);
373 }
374 return res;
375
376 }
377
378 int GL2PSToJOGL::glGetLineStippleRepeat (JavaVM * jvm_){
379
380 JNIEnv * curEnv = NULL;
381 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
382 jclass cls = curEnv->FindClass( className().c_str() );
383
384 jmethodID jintglGetLineStippleRepeatID = curEnv->GetStaticMethodID(cls, "glGetLineStippleRepeat", "()I" ) ;
385 if (jintglGetLineStippleRepeatID == NULL) {
386 throw GiwsException::JniMethodNotFoundException(curEnv, "glGetLineStippleRepeat");
387 }
388
389                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintglGetLineStippleRepeatID ));
390                         curEnv->DeleteLocalRef(cls);
391 if (curEnv->ExceptionCheck()) {
392 throw GiwsException::JniCallMethodException(curEnv);
393 }
394 return res;
395
396 }
397
398 int GL2PSToJOGL::glGetIndexClearValue (JavaVM * jvm_){
399
400 JNIEnv * curEnv = NULL;
401 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
402 jclass cls = curEnv->FindClass( className().c_str() );
403
404 jmethodID jintglGetIndexClearValueID = curEnv->GetStaticMethodID(cls, "glGetIndexClearValue", "()I" ) ;
405 if (jintglGetIndexClearValueID == NULL) {
406 throw GiwsException::JniMethodNotFoundException(curEnv, "glGetIndexClearValue");
407 }
408
409                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintglGetIndexClearValueID ));
410                         curEnv->DeleteLocalRef(cls);
411 if (curEnv->ExceptionCheck()) {
412 throw GiwsException::JniCallMethodException(curEnv);
413 }
414 return res;
415
416 }
417
418 int* GL2PSToJOGL::glGetViewport (JavaVM * jvm_){
419
420 JNIEnv * curEnv = NULL;
421 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
422 jclass cls = curEnv->FindClass( className().c_str() );
423
424 jmethodID jintArray_glGetViewportID = curEnv->GetStaticMethodID(cls, "glGetViewport", "()[I" ) ;
425 if (jintArray_glGetViewportID == NULL) {
426 throw GiwsException::JniMethodNotFoundException(curEnv, "glGetViewport");
427 }
428
429                         jintArray res =  static_cast<jintArray>( curEnv->CallStaticObjectMethod(cls, jintArray_glGetViewportID ));
430                         if (res == NULL) { return NULL; }
431                         if (curEnv->ExceptionCheck()) {
432 throw GiwsException::JniCallMethodException(curEnv);
433 }int lenRow;
434  lenRow = curEnv->GetArrayLength(res);
435 jboolean isCopy = JNI_FALSE;
436
437 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
438 jint *resultsArray = static_cast<jint *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
439 int* myArray= new int[ lenRow];
440
441 for (jsize i = 0; i <  lenRow; i++){
442 myArray[i]=resultsArray[i];
443 }
444 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
445
446                         curEnv->DeleteLocalRef(res);
447 curEnv->DeleteLocalRef(cls);
448 if (curEnv->ExceptionCheck()) {
449 delete[] myArray;
450                                 throw GiwsException::JniCallMethodException(curEnv);
451 }
452 return myArray;
453
454 }
455
456 int GL2PSToJOGL::glGetBlendSrc (JavaVM * jvm_){
457
458 JNIEnv * curEnv = NULL;
459 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
460 jclass cls = curEnv->FindClass( className().c_str() );
461
462 jmethodID jintglGetBlendSrcID = curEnv->GetStaticMethodID(cls, "glGetBlendSrc", "()I" ) ;
463 if (jintglGetBlendSrcID == NULL) {
464 throw GiwsException::JniMethodNotFoundException(curEnv, "glGetBlendSrc");
465 }
466
467                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintglGetBlendSrcID ));
468                         curEnv->DeleteLocalRef(cls);
469 if (curEnv->ExceptionCheck()) {
470 throw GiwsException::JniCallMethodException(curEnv);
471 }
472 return res;
473
474 }
475
476 int GL2PSToJOGL::glGetBlendDst (JavaVM * jvm_){
477
478 JNIEnv * curEnv = NULL;
479 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
480 jclass cls = curEnv->FindClass( className().c_str() );
481
482 jmethodID jintglGetBlendDstID = curEnv->GetStaticMethodID(cls, "glGetBlendDst", "()I" ) ;
483 if (jintglGetBlendDstID == NULL) {
484 throw GiwsException::JniMethodNotFoundException(curEnv, "glGetBlendDst");
485 }
486
487                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintglGetBlendDstID ));
488                         curEnv->DeleteLocalRef(cls);
489 if (curEnv->ExceptionCheck()) {
490 throw GiwsException::JniCallMethodException(curEnv);
491 }
492 return res;
493
494 }
495
496 float* GL2PSToJOGL::glGetColorClearValue (JavaVM * jvm_){
497
498 JNIEnv * curEnv = NULL;
499 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
500 jclass cls = curEnv->FindClass( className().c_str() );
501
502 jmethodID jfloatArray_glGetColorClearValueID = curEnv->GetStaticMethodID(cls, "glGetColorClearValue", "()[F" ) ;
503 if (jfloatArray_glGetColorClearValueID == NULL) {
504 throw GiwsException::JniMethodNotFoundException(curEnv, "glGetColorClearValue");
505 }
506
507                         jfloatArray res =  static_cast<jfloatArray>( curEnv->CallStaticObjectMethod(cls, jfloatArray_glGetColorClearValueID ));
508                         if (res == NULL) { return NULL; }
509                         if (curEnv->ExceptionCheck()) {
510 throw GiwsException::JniCallMethodException(curEnv);
511 }int lenRow;
512  lenRow = curEnv->GetArrayLength(res);
513 jboolean isCopy = JNI_FALSE;
514
515 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
516 jfloat *resultsArray = static_cast<jfloat *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
517 float* myArray= new float[ lenRow];
518
519 for (jsize i = 0; i <  lenRow; i++){
520 myArray[i]=resultsArray[i];
521 }
522 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
523
524                         curEnv->DeleteLocalRef(res);
525 curEnv->DeleteLocalRef(cls);
526 if (curEnv->ExceptionCheck()) {
527 delete[] myArray;
528                                 throw GiwsException::JniCallMethodException(curEnv);
529 }
530 return myArray;
531
532 }
533
534 float GL2PSToJOGL::glGetPolygonOffsetFactor (JavaVM * jvm_){
535
536 JNIEnv * curEnv = NULL;
537 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
538 jclass cls = curEnv->FindClass( className().c_str() );
539
540 jmethodID jfloatglGetPolygonOffsetFactorID = curEnv->GetStaticMethodID(cls, "glGetPolygonOffsetFactor", "()F" ) ;
541 if (jfloatglGetPolygonOffsetFactorID == NULL) {
542 throw GiwsException::JniMethodNotFoundException(curEnv, "glGetPolygonOffsetFactor");
543 }
544
545                         jfloat res =  static_cast<jfloat>( curEnv->CallStaticFloatMethod(cls, jfloatglGetPolygonOffsetFactorID ));
546                         curEnv->DeleteLocalRef(cls);
547 if (curEnv->ExceptionCheck()) {
548 throw GiwsException::JniCallMethodException(curEnv);
549 }
550 return res;
551
552 }
553
554 float GL2PSToJOGL::glGetPolygonOffsetUnits (JavaVM * jvm_){
555
556 JNIEnv * curEnv = NULL;
557 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
558 jclass cls = curEnv->FindClass( className().c_str() );
559
560 jmethodID jfloatglGetPolygonOffsetUnitsID = curEnv->GetStaticMethodID(cls, "glGetPolygonOffsetUnits", "()F" ) ;
561 if (jfloatglGetPolygonOffsetUnitsID == NULL) {
562 throw GiwsException::JniMethodNotFoundException(curEnv, "glGetPolygonOffsetUnits");
563 }
564
565                         jfloat res =  static_cast<jfloat>( curEnv->CallStaticFloatMethod(cls, jfloatglGetPolygonOffsetUnitsID ));
566                         curEnv->DeleteLocalRef(cls);
567 if (curEnv->ExceptionCheck()) {
568 throw GiwsException::JniCallMethodException(curEnv);
569 }
570 return res;
571
572 }
573
574 float* GL2PSToJOGL::glGetCurrentRasterPosition (JavaVM * jvm_){
575
576 JNIEnv * curEnv = NULL;
577 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
578 jclass cls = curEnv->FindClass( className().c_str() );
579
580 jmethodID jfloatArray_glGetCurrentRasterPositionID = curEnv->GetStaticMethodID(cls, "glGetCurrentRasterPosition", "()[F" ) ;
581 if (jfloatArray_glGetCurrentRasterPositionID == NULL) {
582 throw GiwsException::JniMethodNotFoundException(curEnv, "glGetCurrentRasterPosition");
583 }
584
585                         jfloatArray res =  static_cast<jfloatArray>( curEnv->CallStaticObjectMethod(cls, jfloatArray_glGetCurrentRasterPositionID ));
586                         if (res == NULL) { return NULL; }
587                         if (curEnv->ExceptionCheck()) {
588 throw GiwsException::JniCallMethodException(curEnv);
589 }int lenRow;
590  lenRow = curEnv->GetArrayLength(res);
591 jboolean isCopy = JNI_FALSE;
592
593 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
594 jfloat *resultsArray = static_cast<jfloat *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
595 float* myArray= new float[ lenRow];
596
597 for (jsize i = 0; i <  lenRow; i++){
598 myArray[i]=resultsArray[i];
599 }
600 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
601
602                         curEnv->DeleteLocalRef(res);
603 curEnv->DeleteLocalRef(cls);
604 if (curEnv->ExceptionCheck()) {
605 delete[] myArray;
606                                 throw GiwsException::JniCallMethodException(curEnv);
607 }
608 return myArray;
609
610 }
611
612 float* GL2PSToJOGL::glGetCurrentRasterColor (JavaVM * jvm_){
613
614 JNIEnv * curEnv = NULL;
615 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
616 jclass cls = curEnv->FindClass( className().c_str() );
617
618 jmethodID jfloatArray_glGetCurrentRasterColorID = curEnv->GetStaticMethodID(cls, "glGetCurrentRasterColor", "()[F" ) ;
619 if (jfloatArray_glGetCurrentRasterColorID == NULL) {
620 throw GiwsException::JniMethodNotFoundException(curEnv, "glGetCurrentRasterColor");
621 }
622
623                         jfloatArray res =  static_cast<jfloatArray>( curEnv->CallStaticObjectMethod(cls, jfloatArray_glGetCurrentRasterColorID ));
624                         if (res == NULL) { return NULL; }
625                         if (curEnv->ExceptionCheck()) {
626 throw GiwsException::JniCallMethodException(curEnv);
627 }int lenRow;
628  lenRow = curEnv->GetArrayLength(res);
629 jboolean isCopy = JNI_FALSE;
630
631 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
632 jfloat *resultsArray = static_cast<jfloat *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
633 float* myArray= new float[ lenRow];
634
635 for (jsize i = 0; i <  lenRow; i++){
636 myArray[i]=resultsArray[i];
637 }
638 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
639
640                         curEnv->DeleteLocalRef(res);
641 curEnv->DeleteLocalRef(cls);
642 if (curEnv->ExceptionCheck()) {
643 delete[] myArray;
644                                 throw GiwsException::JniCallMethodException(curEnv);
645 }
646 return myArray;
647
648 }
649
650 void GL2PSToJOGL::glPassThrough (JavaVM * jvm_, float arg0){
651
652 JNIEnv * curEnv = NULL;
653 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
654 jclass cls = curEnv->FindClass( className().c_str() );
655
656 jmethodID voidglPassThroughjfloatID = curEnv->GetStaticMethodID(cls, "glPassThrough", "(F)V" ) ;
657 if (voidglPassThroughjfloatID == NULL) {
658 throw GiwsException::JniMethodNotFoundException(curEnv, "glPassThrough");
659 }
660
661                          curEnv->CallStaticVoidMethod(cls, voidglPassThroughjfloatID ,arg0);
662                         curEnv->DeleteLocalRef(cls);
663 if (curEnv->ExceptionCheck()) {
664 throw GiwsException::JniCallMethodException(curEnv);
665 }
666 }
667
668 }