Merge commit 'refs/remotes/origin/5.1'
[scilab.git] / scilab / modules / renderer / src / jni / DrawableFigureGL.cpp
1 #include "DrawableFigureGL.hxx"
2 /* Generated by GIWS (version 1.0.3) */
3 /*
4
5 Copyright 2007-2008 INRIA
6
7 Author : Sylvestre Ledru & others
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_renderer_figureDrawing {
40
41 // Returns the current env
42
43 JNIEnv * DrawableFigureGL::getCurrentEnv() {
44 JNIEnv * curEnv = NULL;
45 this->jvm->AttachCurrentThread((void **) &curEnv, NULL);
46 return curEnv;
47 }
48 // Destructor
49
50 DrawableFigureGL::~DrawableFigureGL() {
51 JNIEnv * curEnv = NULL;
52 this->jvm->AttachCurrentThread((void **) &curEnv, NULL);
53
54 curEnv->DeleteGlobalRef(this->instance);
55 curEnv->DeleteGlobalRef(this->instanceClass);
56 }
57 // Constructors
58
59 DrawableFigureGL::DrawableFigureGL(JavaVM * jvm_) {
60 jmethodID constructObject = NULL ;
61 jobject localInstance ;
62 jclass localClass ;
63 const std::string construct="<init>";
64 const std::string param="()V";
65 jvm=jvm_;
66
67 JNIEnv * curEnv = getCurrentEnv();
68
69 localClass = curEnv->FindClass( this->className().c_str() ) ;
70 if (localClass == NULL) {
71   throw GiwsException::JniClassNotFoundException(curEnv, this->className());
72 }
73
74 this->instanceClass = (jclass) curEnv->NewGlobalRef(localClass) ;
75
76 /* localClass is not needed anymore */
77 curEnv->DeleteLocalRef(localClass);
78
79 if (this->instanceClass == NULL) {
80 throw GiwsException::JniObjectCreationException(curEnv, this->className());
81 }
82
83
84 constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
85 if(constructObject == NULL){
86 throw GiwsException::JniObjectCreationException(curEnv, this->className());
87 }
88
89 localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
90 if(localInstance == NULL){
91 throw GiwsException::JniObjectCreationException(curEnv, this->className());
92 }
93  
94 this->instance = curEnv->NewGlobalRef(localInstance) ;
95 if(this->instance == NULL){
96 throw GiwsException::JniObjectCreationException(curEnv, this->className());
97 }
98 /* localInstance not needed anymore */
99 curEnv->DeleteLocalRef(localInstance);
100
101                 /* Methods ID set to NULL */
102 voiddisplayID=NULL; 
103 voidinitializeDrawingjintID=NULL; 
104 voidendDrawingID=NULL; 
105 voidshowjintID=NULL; 
106 voiddestroyjintID=NULL; 
107 voidsetFigureIndexjintID=NULL; 
108 voiddrawCanvasID=NULL; 
109 voiddrawBackgroundID=NULL; 
110 voidsetBackgroundColorjintID=NULL; 
111 voidsetLogicalOpjintID=NULL; 
112 voidsetColorMapDatajdoubleArrayID=NULL; 
113 jdoubleArraygetColorMapDataID=NULL; 
114 jintgetColorMapSizeID=NULL; 
115 jintgetCanvasWidthID=NULL; 
116 jintgetCanvasHeightID=NULL; 
117 jintsetCanvasSizejintjintID=NULL; 
118 jintgetWindowPosXID=NULL; 
119 jintgetWindowPosYID=NULL; 
120 voidsetWindowPositionjintjintID=NULL; 
121 jintgetWindowWidthID=NULL; 
122 jintgetWindowHeightID=NULL; 
123 voidsetWindowSizejintjintID=NULL; 
124 voidsetInfoMessagejstringID=NULL; 
125 jstringgetInfoMessageID=NULL; 
126 voidsetAutoResizeModejbooleanID=NULL; 
127 jbooleangetAutoResizeModeID=NULL; 
128 jintArraygetViewportID=NULL; 
129 voidsetViewportjintjintjintjintID=NULL; 
130 jintArrayrubberBoxjbooleanjintArrayID=NULL; 
131 voidinteractiveZoomjlongID=NULL; 
132 voidsetTitlejstringID=NULL; 
133 voidinteractiveRotationID=NULL; 
134 voidshowWindowID=NULL; 
135 voidsetNbSubwinsjintID=NULL; 
136 voidopenGraphicCanvasID=NULL; 
137 voidcloseGraphicCanvasID=NULL; 
138 voidsetUseSingleBufferjbooleanID=NULL; 
139 jintgetAntialiasingQualityID=NULL; 
140 voidsetAntialiasingQualityjintID=NULL; 
141
142
143 }
144
145 DrawableFigureGL::DrawableFigureGL(JavaVM * jvm_, jobject JObj) {
146         jvm=jvm_;
147
148         JNIEnv * curEnv = getCurrentEnv();
149
150 jclass localClass = curEnv->GetObjectClass(JObj);
151         this->instanceClass = (jclass) curEnv->NewGlobalRef(localClass);
152         curEnv->DeleteLocalRef(localClass);
153
154         if (this->instanceClass == NULL) {
155 throw GiwsException::JniObjectCreationException(curEnv, this->className());
156         }
157
158         this->instance = curEnv->NewGlobalRef(JObj) ;
159         if(this->instance == NULL){
160 throw GiwsException::JniObjectCreationException(curEnv, this->className());
161         }
162         /* Methods ID set to NULL */
163         voiddisplayID=NULL; 
164 voidinitializeDrawingjintID=NULL; 
165 voidendDrawingID=NULL; 
166 voidshowjintID=NULL; 
167 voiddestroyjintID=NULL; 
168 voidsetFigureIndexjintID=NULL; 
169 voiddrawCanvasID=NULL; 
170 voiddrawBackgroundID=NULL; 
171 voidsetBackgroundColorjintID=NULL; 
172 voidsetLogicalOpjintID=NULL; 
173 voidsetColorMapDatajdoubleArrayID=NULL; 
174 jdoubleArraygetColorMapDataID=NULL; 
175 jintgetColorMapSizeID=NULL; 
176 jintgetCanvasWidthID=NULL; 
177 jintgetCanvasHeightID=NULL; 
178 jintsetCanvasSizejintjintID=NULL; 
179 jintgetWindowPosXID=NULL; 
180 jintgetWindowPosYID=NULL; 
181 voidsetWindowPositionjintjintID=NULL; 
182 jintgetWindowWidthID=NULL; 
183 jintgetWindowHeightID=NULL; 
184 voidsetWindowSizejintjintID=NULL; 
185 voidsetInfoMessagejstringID=NULL; 
186 jstringgetInfoMessageID=NULL; 
187 voidsetAutoResizeModejbooleanID=NULL; 
188 jbooleangetAutoResizeModeID=NULL; 
189 jintArraygetViewportID=NULL; 
190 voidsetViewportjintjintjintjintID=NULL; 
191 jintArrayrubberBoxjbooleanjintArrayID=NULL; 
192 voidinteractiveZoomjlongID=NULL; 
193 voidsetTitlejstringID=NULL; 
194 voidinteractiveRotationID=NULL; 
195 voidshowWindowID=NULL; 
196 voidsetNbSubwinsjintID=NULL; 
197 voidopenGraphicCanvasID=NULL; 
198 voidcloseGraphicCanvasID=NULL; 
199 voidsetUseSingleBufferjbooleanID=NULL; 
200 jintgetAntialiasingQualityID=NULL; 
201 voidsetAntialiasingQualityjintID=NULL; 
202
203
204 }
205
206 // Generic methods
207
208 void DrawableFigureGL::synchronize() {
209 if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
210 throw GiwsException::JniMonitorException(getCurrentEnv(), "DrawableFigureGL");
211 }
212 }
213
214 void DrawableFigureGL::endSynchronize() {
215 if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
216 throw GiwsException::JniMonitorException(getCurrentEnv(), "DrawableFigureGL");
217 }
218 }
219 // Method(s)
220
221 void DrawableFigureGL::display (){
222
223 JNIEnv * curEnv = getCurrentEnv();
224
225 if (voiddisplayID==NULL) { /* Use the cache Luke */ voiddisplayID = curEnv->GetMethodID(this->instanceClass, "display", "()V" ) ;
226 if (voiddisplayID == NULL) {
227 throw GiwsException::JniMethodNotFoundException(curEnv, "display");
228 }
229 }
230                          curEnv->CallVoidMethod( this->instance, voiddisplayID );
231                         if (curEnv->ExceptionCheck()) {
232 throw GiwsException::JniCallMethodException(curEnv);
233 }
234 }
235
236 void DrawableFigureGL::initializeDrawing (int figureIndex){
237
238 JNIEnv * curEnv = getCurrentEnv();
239
240 if (voidinitializeDrawingjintID==NULL) { /* Use the cache Luke */ voidinitializeDrawingjintID = curEnv->GetMethodID(this->instanceClass, "initializeDrawing", "(I)V" ) ;
241 if (voidinitializeDrawingjintID == NULL) {
242 throw GiwsException::JniMethodNotFoundException(curEnv, "initializeDrawing");
243 }
244 }
245                          curEnv->CallVoidMethod( this->instance, voidinitializeDrawingjintID ,figureIndex);
246                         if (curEnv->ExceptionCheck()) {
247 throw GiwsException::JniCallMethodException(curEnv);
248 }
249 }
250
251 void DrawableFigureGL::endDrawing (){
252
253 JNIEnv * curEnv = getCurrentEnv();
254
255 if (voidendDrawingID==NULL) { /* Use the cache Luke */ voidendDrawingID = curEnv->GetMethodID(this->instanceClass, "endDrawing", "()V" ) ;
256 if (voidendDrawingID == NULL) {
257 throw GiwsException::JniMethodNotFoundException(curEnv, "endDrawing");
258 }
259 }
260                          curEnv->CallVoidMethod( this->instance, voidendDrawingID );
261                         if (curEnv->ExceptionCheck()) {
262 throw GiwsException::JniCallMethodException(curEnv);
263 }
264 }
265
266 void DrawableFigureGL::show (int figureIndex){
267
268 JNIEnv * curEnv = getCurrentEnv();
269
270 if (voidshowjintID==NULL) { /* Use the cache Luke */ voidshowjintID = curEnv->GetMethodID(this->instanceClass, "show", "(I)V" ) ;
271 if (voidshowjintID == NULL) {
272 throw GiwsException::JniMethodNotFoundException(curEnv, "show");
273 }
274 }
275                          curEnv->CallVoidMethod( this->instance, voidshowjintID ,figureIndex);
276                         if (curEnv->ExceptionCheck()) {
277 throw GiwsException::JniCallMethodException(curEnv);
278 }
279 }
280
281 void DrawableFigureGL::destroy (int parentFigureIndex){
282
283 JNIEnv * curEnv = getCurrentEnv();
284
285 if (voiddestroyjintID==NULL) { /* Use the cache Luke */ voiddestroyjintID = curEnv->GetMethodID(this->instanceClass, "destroy", "(I)V" ) ;
286 if (voiddestroyjintID == NULL) {
287 throw GiwsException::JniMethodNotFoundException(curEnv, "destroy");
288 }
289 }
290                          curEnv->CallVoidMethod( this->instance, voiddestroyjintID ,parentFigureIndex);
291                         if (curEnv->ExceptionCheck()) {
292 throw GiwsException::JniCallMethodException(curEnv);
293 }
294 }
295
296 void DrawableFigureGL::setFigureIndex (int figureIndex){
297
298 JNIEnv * curEnv = getCurrentEnv();
299
300 if (voidsetFigureIndexjintID==NULL) { /* Use the cache Luke */ voidsetFigureIndexjintID = curEnv->GetMethodID(this->instanceClass, "setFigureIndex", "(I)V" ) ;
301 if (voidsetFigureIndexjintID == NULL) {
302 throw GiwsException::JniMethodNotFoundException(curEnv, "setFigureIndex");
303 }
304 }
305                          curEnv->CallVoidMethod( this->instance, voidsetFigureIndexjintID ,figureIndex);
306                         if (curEnv->ExceptionCheck()) {
307 throw GiwsException::JniCallMethodException(curEnv);
308 }
309 }
310
311 void DrawableFigureGL::drawCanvas (){
312
313 JNIEnv * curEnv = getCurrentEnv();
314
315 if (voiddrawCanvasID==NULL) { /* Use the cache Luke */ voiddrawCanvasID = curEnv->GetMethodID(this->instanceClass, "drawCanvas", "()V" ) ;
316 if (voiddrawCanvasID == NULL) {
317 throw GiwsException::JniMethodNotFoundException(curEnv, "drawCanvas");
318 }
319 }
320                          curEnv->CallVoidMethod( this->instance, voiddrawCanvasID );
321                         if (curEnv->ExceptionCheck()) {
322 throw GiwsException::JniCallMethodException(curEnv);
323 }
324 }
325
326 void DrawableFigureGL::drawBackground (){
327
328 JNIEnv * curEnv = getCurrentEnv();
329
330 if (voiddrawBackgroundID==NULL) { /* Use the cache Luke */ voiddrawBackgroundID = curEnv->GetMethodID(this->instanceClass, "drawBackground", "()V" ) ;
331 if (voiddrawBackgroundID == NULL) {
332 throw GiwsException::JniMethodNotFoundException(curEnv, "drawBackground");
333 }
334 }
335                          curEnv->CallVoidMethod( this->instance, voiddrawBackgroundID );
336                         if (curEnv->ExceptionCheck()) {
337 throw GiwsException::JniCallMethodException(curEnv);
338 }
339 }
340
341 void DrawableFigureGL::setBackgroundColor (int colorIndex){
342
343 JNIEnv * curEnv = getCurrentEnv();
344
345 if (voidsetBackgroundColorjintID==NULL) { /* Use the cache Luke */ voidsetBackgroundColorjintID = curEnv->GetMethodID(this->instanceClass, "setBackgroundColor", "(I)V" ) ;
346 if (voidsetBackgroundColorjintID == NULL) {
347 throw GiwsException::JniMethodNotFoundException(curEnv, "setBackgroundColor");
348 }
349 }
350                          curEnv->CallVoidMethod( this->instance, voidsetBackgroundColorjintID ,colorIndex);
351                         if (curEnv->ExceptionCheck()) {
352 throw GiwsException::JniCallMethodException(curEnv);
353 }
354 }
355
356 void DrawableFigureGL::setLogicalOp (int logicOpIndex){
357
358 JNIEnv * curEnv = getCurrentEnv();
359
360 if (voidsetLogicalOpjintID==NULL) { /* Use the cache Luke */ voidsetLogicalOpjintID = curEnv->GetMethodID(this->instanceClass, "setLogicalOp", "(I)V" ) ;
361 if (voidsetLogicalOpjintID == NULL) {
362 throw GiwsException::JniMethodNotFoundException(curEnv, "setLogicalOp");
363 }
364 }
365                          curEnv->CallVoidMethod( this->instance, voidsetLogicalOpjintID ,logicOpIndex);
366                         if (curEnv->ExceptionCheck()) {
367 throw GiwsException::JniCallMethodException(curEnv);
368 }
369 }
370
371 void DrawableFigureGL::setColorMapData (double * rgbmat, int rgbmatSize){
372
373 JNIEnv * curEnv = getCurrentEnv();
374
375 if (voidsetColorMapDatajdoubleArrayID==NULL) { /* Use the cache Luke */ voidsetColorMapDatajdoubleArrayID = curEnv->GetMethodID(this->instanceClass, "setColorMapData", "([D)V" ) ;
376 if (voidsetColorMapDatajdoubleArrayID == NULL) {
377 throw GiwsException::JniMethodNotFoundException(curEnv, "setColorMapData");
378 }
379 }
380 jdoubleArray rgbmat_ = curEnv->NewDoubleArray( rgbmatSize ) ;
381
382 if (rgbmat_ == NULL)
383 {
384 // check that allocation succeed
385 throw GiwsException::JniBadAllocException(curEnv);
386 }
387
388 curEnv->SetDoubleArrayRegion( rgbmat_, 0, rgbmatSize, (jdouble*) rgbmat ) ;
389
390
391                          curEnv->CallVoidMethod( this->instance, voidsetColorMapDatajdoubleArrayID ,rgbmat_);
392                         curEnv->DeleteLocalRef(rgbmat_);
393 if (curEnv->ExceptionCheck()) {
394 throw GiwsException::JniCallMethodException(curEnv);
395 }
396 }
397
398 double * DrawableFigureGL::getColorMapData (){
399
400 JNIEnv * curEnv = getCurrentEnv();
401
402 if (jdoubleArraygetColorMapDataID==NULL) { /* Use the cache Luke */ jdoubleArraygetColorMapDataID = curEnv->GetMethodID(this->instanceClass, "getColorMapData", "()[D" ) ;
403 if (jdoubleArraygetColorMapDataID == NULL) {
404 throw GiwsException::JniMethodNotFoundException(curEnv, "getColorMapData");
405 }
406 }
407                         jdoubleArray res =  (jdoubleArray) curEnv->CallObjectMethod( this->instance, jdoubleArraygetColorMapDataID );
408                         
409 jsize len = curEnv->GetArrayLength(res);
410 jboolean isCopy = JNI_FALSE;
411
412 /* faster than getXXXArrayElements */
413 jdouble *resultsArray = (jdouble *) curEnv->GetPrimitiveArrayCritical(res, &isCopy);
414 double * myArray= new double[len];
415
416 for (jsize i = 0; i < len; i++){
417 myArray[i]=resultsArray[i];
418 }
419 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
420
421                         curEnv->DeleteLocalRef(res);
422 if (curEnv->ExceptionCheck()) {
423 throw GiwsException::JniCallMethodException(curEnv);
424 }
425 return myArray;
426
427 }
428
429 int DrawableFigureGL::getColorMapSize (){
430
431 JNIEnv * curEnv = getCurrentEnv();
432
433 if (jintgetColorMapSizeID==NULL) { /* Use the cache Luke */ jintgetColorMapSizeID = curEnv->GetMethodID(this->instanceClass, "getColorMapSize", "()I" ) ;
434 if (jintgetColorMapSizeID == NULL) {
435 throw GiwsException::JniMethodNotFoundException(curEnv, "getColorMapSize");
436 }
437 }
438                         jint res =  (jint) curEnv->CallIntMethod( this->instance, jintgetColorMapSizeID );
439                         if (curEnv->ExceptionCheck()) {
440 throw GiwsException::JniCallMethodException(curEnv);
441 }
442 return res;
443
444 }
445
446 int DrawableFigureGL::getCanvasWidth (){
447
448 JNIEnv * curEnv = getCurrentEnv();
449
450 if (jintgetCanvasWidthID==NULL) { /* Use the cache Luke */ jintgetCanvasWidthID = curEnv->GetMethodID(this->instanceClass, "getCanvasWidth", "()I" ) ;
451 if (jintgetCanvasWidthID == NULL) {
452 throw GiwsException::JniMethodNotFoundException(curEnv, "getCanvasWidth");
453 }
454 }
455                         jint res =  (jint) curEnv->CallIntMethod( this->instance, jintgetCanvasWidthID );
456                         if (curEnv->ExceptionCheck()) {
457 throw GiwsException::JniCallMethodException(curEnv);
458 }
459 return res;
460
461 }
462
463 int DrawableFigureGL::getCanvasHeight (){
464
465 JNIEnv * curEnv = getCurrentEnv();
466
467 if (jintgetCanvasHeightID==NULL) { /* Use the cache Luke */ jintgetCanvasHeightID = curEnv->GetMethodID(this->instanceClass, "getCanvasHeight", "()I" ) ;
468 if (jintgetCanvasHeightID == NULL) {
469 throw GiwsException::JniMethodNotFoundException(curEnv, "getCanvasHeight");
470 }
471 }
472                         jint res =  (jint) curEnv->CallIntMethod( this->instance, jintgetCanvasHeightID );
473                         if (curEnv->ExceptionCheck()) {
474 throw GiwsException::JniCallMethodException(curEnv);
475 }
476 return res;
477
478 }
479
480 int DrawableFigureGL::setCanvasSize (int width, int height){
481
482 JNIEnv * curEnv = getCurrentEnv();
483
484 if (jintsetCanvasSizejintjintID==NULL) { /* Use the cache Luke */ jintsetCanvasSizejintjintID = curEnv->GetMethodID(this->instanceClass, "setCanvasSize", "(II)I" ) ;
485 if (jintsetCanvasSizejintjintID == NULL) {
486 throw GiwsException::JniMethodNotFoundException(curEnv, "setCanvasSize");
487 }
488 }
489                         jint res =  (jint) curEnv->CallIntMethod( this->instance, jintsetCanvasSizejintjintID ,width, height);
490                         if (curEnv->ExceptionCheck()) {
491 throw GiwsException::JniCallMethodException(curEnv);
492 }
493 return res;
494
495 }
496
497 int DrawableFigureGL::getWindowPosX (){
498
499 JNIEnv * curEnv = getCurrentEnv();
500
501 if (jintgetWindowPosXID==NULL) { /* Use the cache Luke */ jintgetWindowPosXID = curEnv->GetMethodID(this->instanceClass, "getWindowPosX", "()I" ) ;
502 if (jintgetWindowPosXID == NULL) {
503 throw GiwsException::JniMethodNotFoundException(curEnv, "getWindowPosX");
504 }
505 }
506                         jint res =  (jint) curEnv->CallIntMethod( this->instance, jintgetWindowPosXID );
507                         if (curEnv->ExceptionCheck()) {
508 throw GiwsException::JniCallMethodException(curEnv);
509 }
510 return res;
511
512 }
513
514 int DrawableFigureGL::getWindowPosY (){
515
516 JNIEnv * curEnv = getCurrentEnv();
517
518 if (jintgetWindowPosYID==NULL) { /* Use the cache Luke */ jintgetWindowPosYID = curEnv->GetMethodID(this->instanceClass, "getWindowPosY", "()I" ) ;
519 if (jintgetWindowPosYID == NULL) {
520 throw GiwsException::JniMethodNotFoundException(curEnv, "getWindowPosY");
521 }
522 }
523                         jint res =  (jint) curEnv->CallIntMethod( this->instance, jintgetWindowPosYID );
524                         if (curEnv->ExceptionCheck()) {
525 throw GiwsException::JniCallMethodException(curEnv);
526 }
527 return res;
528
529 }
530
531 void DrawableFigureGL::setWindowPosition (int posX, int posY){
532
533 JNIEnv * curEnv = getCurrentEnv();
534
535 if (voidsetWindowPositionjintjintID==NULL) { /* Use the cache Luke */ voidsetWindowPositionjintjintID = curEnv->GetMethodID(this->instanceClass, "setWindowPosition", "(II)V" ) ;
536 if (voidsetWindowPositionjintjintID == NULL) {
537 throw GiwsException::JniMethodNotFoundException(curEnv, "setWindowPosition");
538 }
539 }
540                          curEnv->CallVoidMethod( this->instance, voidsetWindowPositionjintjintID ,posX, posY);
541                         if (curEnv->ExceptionCheck()) {
542 throw GiwsException::JniCallMethodException(curEnv);
543 }
544 }
545
546 int DrawableFigureGL::getWindowWidth (){
547
548 JNIEnv * curEnv = getCurrentEnv();
549
550 if (jintgetWindowWidthID==NULL) { /* Use the cache Luke */ jintgetWindowWidthID = curEnv->GetMethodID(this->instanceClass, "getWindowWidth", "()I" ) ;
551 if (jintgetWindowWidthID == NULL) {
552 throw GiwsException::JniMethodNotFoundException(curEnv, "getWindowWidth");
553 }
554 }
555                         jint res =  (jint) curEnv->CallIntMethod( this->instance, jintgetWindowWidthID );
556                         if (curEnv->ExceptionCheck()) {
557 throw GiwsException::JniCallMethodException(curEnv);
558 }
559 return res;
560
561 }
562
563 int DrawableFigureGL::getWindowHeight (){
564
565 JNIEnv * curEnv = getCurrentEnv();
566
567 if (jintgetWindowHeightID==NULL) { /* Use the cache Luke */ jintgetWindowHeightID = curEnv->GetMethodID(this->instanceClass, "getWindowHeight", "()I" ) ;
568 if (jintgetWindowHeightID == NULL) {
569 throw GiwsException::JniMethodNotFoundException(curEnv, "getWindowHeight");
570 }
571 }
572                         jint res =  (jint) curEnv->CallIntMethod( this->instance, jintgetWindowHeightID );
573                         if (curEnv->ExceptionCheck()) {
574 throw GiwsException::JniCallMethodException(curEnv);
575 }
576 return res;
577
578 }
579
580 void DrawableFigureGL::setWindowSize (int width, int height){
581
582 JNIEnv * curEnv = getCurrentEnv();
583
584 if (voidsetWindowSizejintjintID==NULL) { /* Use the cache Luke */ voidsetWindowSizejintjintID = curEnv->GetMethodID(this->instanceClass, "setWindowSize", "(II)V" ) ;
585 if (voidsetWindowSizejintjintID == NULL) {
586 throw GiwsException::JniMethodNotFoundException(curEnv, "setWindowSize");
587 }
588 }
589                          curEnv->CallVoidMethod( this->instance, voidsetWindowSizejintjintID ,width, height);
590                         if (curEnv->ExceptionCheck()) {
591 throw GiwsException::JniCallMethodException(curEnv);
592 }
593 }
594
595 void DrawableFigureGL::setInfoMessage (char * infoMessage){
596
597 JNIEnv * curEnv = getCurrentEnv();
598
599 if (voidsetInfoMessagejstringID==NULL) { /* Use the cache Luke */ voidsetInfoMessagejstringID = curEnv->GetMethodID(this->instanceClass, "setInfoMessage", "(Ljava/lang/String;)V" ) ;
600 if (voidsetInfoMessagejstringID == NULL) {
601 throw GiwsException::JniMethodNotFoundException(curEnv, "setInfoMessage");
602 }
603 }
604 jstring infoMessage_ = curEnv->NewStringUTF( infoMessage );
605
606                          curEnv->CallVoidMethod( this->instance, voidsetInfoMessagejstringID ,infoMessage_);
607                         if (curEnv->ExceptionCheck()) {
608 throw GiwsException::JniCallMethodException(curEnv);
609 }
610 }
611
612 char * DrawableFigureGL::getInfoMessage (){
613
614 JNIEnv * curEnv = getCurrentEnv();
615
616 if (jstringgetInfoMessageID==NULL) { /* Use the cache Luke */ jstringgetInfoMessageID = curEnv->GetMethodID(this->instanceClass, "getInfoMessage", "()Ljava/lang/String;" ) ;
617 if (jstringgetInfoMessageID == NULL) {
618 throw GiwsException::JniMethodNotFoundException(curEnv, "getInfoMessage");
619 }
620 }
621                         jstring res =  (jstring) curEnv->CallObjectMethod( this->instance, jstringgetInfoMessageID );
622                         if (curEnv->ExceptionCheck()) {
623 throw GiwsException::JniCallMethodException(curEnv);
624 }
625
626 const char *tempString = curEnv->GetStringUTFChars(res, 0);
627 char * myStringBuffer = new char[strlen(tempString) + 1];
628 strcpy(myStringBuffer, tempString);
629 curEnv->ReleaseStringUTFChars(res, tempString);
630 curEnv->DeleteLocalRef(res);
631 if (curEnv->ExceptionCheck()) {
632 throw GiwsException::JniCallMethodException(curEnv);
633 }
634 return myStringBuffer;
635
636 }
637
638 void DrawableFigureGL::setAutoResizeMode (bool onOrOff){
639
640 JNIEnv * curEnv = getCurrentEnv();
641
642 if (voidsetAutoResizeModejbooleanID==NULL) { /* Use the cache Luke */ voidsetAutoResizeModejbooleanID = curEnv->GetMethodID(this->instanceClass, "setAutoResizeMode", "(Z)V" ) ;
643 if (voidsetAutoResizeModejbooleanID == NULL) {
644 throw GiwsException::JniMethodNotFoundException(curEnv, "setAutoResizeMode");
645 }
646 }
647 jboolean onOrOff_ = ((bool) onOrOff ? JNI_TRUE : JNI_FALSE);
648
649                          curEnv->CallVoidMethod( this->instance, voidsetAutoResizeModejbooleanID ,onOrOff_);
650                         if (curEnv->ExceptionCheck()) {
651 throw GiwsException::JniCallMethodException(curEnv);
652 }
653 }
654
655 bool DrawableFigureGL::getAutoResizeMode (){
656
657 JNIEnv * curEnv = getCurrentEnv();
658
659 if (jbooleangetAutoResizeModeID==NULL) { /* Use the cache Luke */ jbooleangetAutoResizeModeID = curEnv->GetMethodID(this->instanceClass, "getAutoResizeMode", "()Z" ) ;
660 if (jbooleangetAutoResizeModeID == NULL) {
661 throw GiwsException::JniMethodNotFoundException(curEnv, "getAutoResizeMode");
662 }
663 }
664                         jboolean res =  (jboolean) curEnv->CallBooleanMethod( this->instance, jbooleangetAutoResizeModeID );
665                         if (curEnv->ExceptionCheck()) {
666 throw GiwsException::JniCallMethodException(curEnv);
667 }
668 return (res == JNI_TRUE);
669
670 }
671
672 int * DrawableFigureGL::getViewport (){
673
674 JNIEnv * curEnv = getCurrentEnv();
675
676 if (jintArraygetViewportID==NULL) { /* Use the cache Luke */ jintArraygetViewportID = curEnv->GetMethodID(this->instanceClass, "getViewport", "()[I" ) ;
677 if (jintArraygetViewportID == NULL) {
678 throw GiwsException::JniMethodNotFoundException(curEnv, "getViewport");
679 }
680 }
681                         jintArray res =  (jintArray) curEnv->CallObjectMethod( this->instance, jintArraygetViewportID );
682                         
683 jsize len = curEnv->GetArrayLength(res);
684 jboolean isCopy = JNI_FALSE;
685
686 /* faster than getXXXArrayElements */
687 jint *resultsArray = (jint *) curEnv->GetPrimitiveArrayCritical(res, &isCopy);
688 int * myArray= new int[len];
689
690 for (jsize i = 0; i < len; i++){
691 myArray[i]=resultsArray[i];
692 }
693 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
694
695                         curEnv->DeleteLocalRef(res);
696 if (curEnv->ExceptionCheck()) {
697 throw GiwsException::JniCallMethodException(curEnv);
698 }
699 return myArray;
700
701 }
702
703 void DrawableFigureGL::setViewport (int posX, int posY, int width, int height){
704
705 JNIEnv * curEnv = getCurrentEnv();
706
707 if (voidsetViewportjintjintjintjintID==NULL) { /* Use the cache Luke */ voidsetViewportjintjintjintjintID = curEnv->GetMethodID(this->instanceClass, "setViewport", "(IIII)V" ) ;
708 if (voidsetViewportjintjintjintjintID == NULL) {
709 throw GiwsException::JniMethodNotFoundException(curEnv, "setViewport");
710 }
711 }
712                          curEnv->CallVoidMethod( this->instance, voidsetViewportjintjintjintjintID ,posX, posY, width, height);
713                         if (curEnv->ExceptionCheck()) {
714 throw GiwsException::JniCallMethodException(curEnv);
715 }
716 }
717
718 int * DrawableFigureGL::rubberBox (bool isClick, int * initialRect, int initialRectSize){
719
720 JNIEnv * curEnv = getCurrentEnv();
721
722 if (jintArrayrubberBoxjbooleanjintArrayID==NULL) { /* Use the cache Luke */ jintArrayrubberBoxjbooleanjintArrayID = curEnv->GetMethodID(this->instanceClass, "rubberBox", "(Z[I)[I" ) ;
723 if (jintArrayrubberBoxjbooleanjintArrayID == NULL) {
724 throw GiwsException::JniMethodNotFoundException(curEnv, "rubberBox");
725 }
726 }
727 jboolean isClick_ = ((bool) isClick ? JNI_TRUE : JNI_FALSE);
728
729 jintArray initialRect_ = curEnv->NewIntArray( initialRectSize ) ;
730
731 if (initialRect_ == NULL)
732 {
733 // check that allocation succeed
734 throw GiwsException::JniBadAllocException(curEnv);
735 }
736
737 curEnv->SetIntArrayRegion( initialRect_, 0, initialRectSize, (jint*) initialRect ) ;
738
739
740                         jintArray res =  (jintArray) curEnv->CallObjectMethod( this->instance, jintArrayrubberBoxjbooleanjintArrayID ,isClick_, initialRect_);
741                         
742 jsize len = curEnv->GetArrayLength(res);
743 jboolean isCopy = JNI_FALSE;
744
745 /* faster than getXXXArrayElements */
746 jint *resultsArray = (jint *) curEnv->GetPrimitiveArrayCritical(res, &isCopy);
747 int * myArray= new int[len];
748
749 for (jsize i = 0; i < len; i++){
750 myArray[i]=resultsArray[i];
751 }
752 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
753
754                         curEnv->DeleteLocalRef(res);
755 curEnv->DeleteLocalRef(initialRect_);
756 if (curEnv->ExceptionCheck()) {
757 throw GiwsException::JniCallMethodException(curEnv);
758 }
759 return myArray;
760
761 }
762
763 void DrawableFigureGL::interactiveZoom (long long objectHandle){
764
765 JNIEnv * curEnv = getCurrentEnv();
766
767 if (voidinteractiveZoomjlongID==NULL) { /* Use the cache Luke */ voidinteractiveZoomjlongID = curEnv->GetMethodID(this->instanceClass, "interactiveZoom", "(J)V" ) ;
768 if (voidinteractiveZoomjlongID == NULL) {
769 throw GiwsException::JniMethodNotFoundException(curEnv, "interactiveZoom");
770 }
771 }
772                          curEnv->CallVoidMethod( this->instance, voidinteractiveZoomjlongID ,objectHandle);
773                         if (curEnv->ExceptionCheck()) {
774 throw GiwsException::JniCallMethodException(curEnv);
775 }
776 }
777
778 void DrawableFigureGL::setTitle (char * title){
779
780 JNIEnv * curEnv = getCurrentEnv();
781
782 if (voidsetTitlejstringID==NULL) { /* Use the cache Luke */ voidsetTitlejstringID = curEnv->GetMethodID(this->instanceClass, "setTitle", "(Ljava/lang/String;)V" ) ;
783 if (voidsetTitlejstringID == NULL) {
784 throw GiwsException::JniMethodNotFoundException(curEnv, "setTitle");
785 }
786 }
787 jstring title_ = curEnv->NewStringUTF( title );
788
789                          curEnv->CallVoidMethod( this->instance, voidsetTitlejstringID ,title_);
790                         if (curEnv->ExceptionCheck()) {
791 throw GiwsException::JniCallMethodException(curEnv);
792 }
793 }
794
795 void DrawableFigureGL::interactiveRotation (){
796
797 JNIEnv * curEnv = getCurrentEnv();
798
799 if (voidinteractiveRotationID==NULL) { /* Use the cache Luke */ voidinteractiveRotationID = curEnv->GetMethodID(this->instanceClass, "interactiveRotation", "()V" ) ;
800 if (voidinteractiveRotationID == NULL) {
801 throw GiwsException::JniMethodNotFoundException(curEnv, "interactiveRotation");
802 }
803 }
804                          curEnv->CallVoidMethod( this->instance, voidinteractiveRotationID );
805                         if (curEnv->ExceptionCheck()) {
806 throw GiwsException::JniCallMethodException(curEnv);
807 }
808 }
809
810 void DrawableFigureGL::showWindow (){
811
812 JNIEnv * curEnv = getCurrentEnv();
813
814 if (voidshowWindowID==NULL) { /* Use the cache Luke */ voidshowWindowID = curEnv->GetMethodID(this->instanceClass, "showWindow", "()V" ) ;
815 if (voidshowWindowID == NULL) {
816 throw GiwsException::JniMethodNotFoundException(curEnv, "showWindow");
817 }
818 }
819                          curEnv->CallVoidMethod( this->instance, voidshowWindowID );
820                         if (curEnv->ExceptionCheck()) {
821 throw GiwsException::JniCallMethodException(curEnv);
822 }
823 }
824
825 void DrawableFigureGL::setNbSubwins (int nbSubwins){
826
827 JNIEnv * curEnv = getCurrentEnv();
828
829 if (voidsetNbSubwinsjintID==NULL) { /* Use the cache Luke */ voidsetNbSubwinsjintID = curEnv->GetMethodID(this->instanceClass, "setNbSubwins", "(I)V" ) ;
830 if (voidsetNbSubwinsjintID == NULL) {
831 throw GiwsException::JniMethodNotFoundException(curEnv, "setNbSubwins");
832 }
833 }
834                          curEnv->CallVoidMethod( this->instance, voidsetNbSubwinsjintID ,nbSubwins);
835                         if (curEnv->ExceptionCheck()) {
836 throw GiwsException::JniCallMethodException(curEnv);
837 }
838 }
839
840 void DrawableFigureGL::openGraphicCanvas (){
841
842 JNIEnv * curEnv = getCurrentEnv();
843
844 if (voidopenGraphicCanvasID==NULL) { /* Use the cache Luke */ voidopenGraphicCanvasID = curEnv->GetMethodID(this->instanceClass, "openGraphicCanvas", "()V" ) ;
845 if (voidopenGraphicCanvasID == NULL) {
846 throw GiwsException::JniMethodNotFoundException(curEnv, "openGraphicCanvas");
847 }
848 }
849                          curEnv->CallVoidMethod( this->instance, voidopenGraphicCanvasID );
850                         if (curEnv->ExceptionCheck()) {
851 throw GiwsException::JniCallMethodException(curEnv);
852 }
853 }
854
855 void DrawableFigureGL::closeGraphicCanvas (){
856
857 JNIEnv * curEnv = getCurrentEnv();
858
859 if (voidcloseGraphicCanvasID==NULL) { /* Use the cache Luke */ voidcloseGraphicCanvasID = curEnv->GetMethodID(this->instanceClass, "closeGraphicCanvas", "()V" ) ;
860 if (voidcloseGraphicCanvasID == NULL) {
861 throw GiwsException::JniMethodNotFoundException(curEnv, "closeGraphicCanvas");
862 }
863 }
864                          curEnv->CallVoidMethod( this->instance, voidcloseGraphicCanvasID );
865                         if (curEnv->ExceptionCheck()) {
866 throw GiwsException::JniCallMethodException(curEnv);
867 }
868 }
869
870 void DrawableFigureGL::setUseSingleBuffer (bool useSingleBuffer){
871
872 JNIEnv * curEnv = getCurrentEnv();
873
874 if (voidsetUseSingleBufferjbooleanID==NULL) { /* Use the cache Luke */ voidsetUseSingleBufferjbooleanID = curEnv->GetMethodID(this->instanceClass, "setUseSingleBuffer", "(Z)V" ) ;
875 if (voidsetUseSingleBufferjbooleanID == NULL) {
876 throw GiwsException::JniMethodNotFoundException(curEnv, "setUseSingleBuffer");
877 }
878 }
879 jboolean useSingleBuffer_ = ((bool) useSingleBuffer ? JNI_TRUE : JNI_FALSE);
880
881                          curEnv->CallVoidMethod( this->instance, voidsetUseSingleBufferjbooleanID ,useSingleBuffer_);
882                         if (curEnv->ExceptionCheck()) {
883 throw GiwsException::JniCallMethodException(curEnv);
884 }
885 }
886
887 int DrawableFigureGL::getAntialiasingQuality (){
888
889 JNIEnv * curEnv = getCurrentEnv();
890
891 if (jintgetAntialiasingQualityID==NULL) { /* Use the cache Luke */ jintgetAntialiasingQualityID = curEnv->GetMethodID(this->instanceClass, "getAntialiasingQuality", "()I" ) ;
892 if (jintgetAntialiasingQualityID == NULL) {
893 throw GiwsException::JniMethodNotFoundException(curEnv, "getAntialiasingQuality");
894 }
895 }
896                         jint res =  (jint) curEnv->CallIntMethod( this->instance, jintgetAntialiasingQualityID );
897                         if (curEnv->ExceptionCheck()) {
898 throw GiwsException::JniCallMethodException(curEnv);
899 }
900 return res;
901
902 }
903
904 void DrawableFigureGL::setAntialiasingQuality (int quality){
905
906 JNIEnv * curEnv = getCurrentEnv();
907
908 if (voidsetAntialiasingQualityjintID==NULL) { /* Use the cache Luke */ voidsetAntialiasingQualityjintID = curEnv->GetMethodID(this->instanceClass, "setAntialiasingQuality", "(I)V" ) ;
909 if (voidsetAntialiasingQualityjintID == NULL) {
910 throw GiwsException::JniMethodNotFoundException(curEnv, "setAntialiasingQuality");
911 }
912 }
913                          curEnv->CallVoidMethod( this->instance, voidsetAntialiasingQualityjintID ,quality);
914                         if (curEnv->ExceptionCheck()) {
915 throw GiwsException::JniCallMethodException(curEnv);
916 }
917 }
918
919 }