Plug rubberbox function :
[scilab.git] / scilab / modules / renderer / src / jni / CallRenderer.cpp
1 #include "CallRenderer.hxx"
2 /* Generated by GIWS (version 2.0.1) with command:
3 giws --disable-return-size-array --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/renderer.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_renderer {
40
41                 // Static declarations (if any)
42                 
43 // Returns the current env
44
45 JNIEnv * CallRenderer::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 CallRenderer::~CallRenderer() {
56 JNIEnv * curEnv = NULL;
57 this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
58
59 curEnv->DeleteGlobalRef(this->instance);
60 curEnv->DeleteGlobalRef(this->instanceClass);
61 }
62 // Constructors
63 CallRenderer::CallRenderer(JavaVM * jvm_) {
64 jmethodID constructObject = NULL ;
65 jobject localInstance ;
66 jclass localClass ;
67
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 voidstartInteractiveZoomjstringjava_lang_StringID=NULL;
108 jdoubleArray_clickRubberBoxjstringjava_lang_StringjdoubleArray_doubledoubleID=NULL;
109 jdoubleArray_dragRubberBoxjstringjava_lang_StringID=NULL;
110 voidupdateTextBoundsjstringjava_lang_StringID=NULL;
111 voidupdateSubwinScalejstringjava_lang_StringID=NULL;
112 jdoubleArray_get2dViewCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID=NULL;
113 jdoubleArray_getPixelFrom2dViewCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID=NULL;
114 jdoubleArray_get2dViewFromPixelCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID=NULL;
115 jdoubleArray_getViewingAreajstringjava_lang_StringID=NULL;
116
117
118 }
119
120 CallRenderer::CallRenderer(JavaVM * jvm_, jobject JObj) {
121         jvm=jvm_;
122
123         JNIEnv * curEnv = getCurrentEnv();
124
125 jclass localClass = curEnv->GetObjectClass(JObj);
126         this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
127         curEnv->DeleteLocalRef(localClass);
128
129         if (this->instanceClass == NULL) {
130 throw GiwsException::JniObjectCreationException(curEnv, this->className());
131         }
132
133         this->instance = curEnv->NewGlobalRef(JObj) ;
134         if(this->instance == NULL){
135 throw GiwsException::JniObjectCreationException(curEnv, this->className());
136         }
137         /* Methods ID set to NULL */
138         voidstartInteractiveZoomjstringjava_lang_StringID=NULL;
139 jdoubleArray_clickRubberBoxjstringjava_lang_StringjdoubleArray_doubledoubleID=NULL;
140 jdoubleArray_dragRubberBoxjstringjava_lang_StringID=NULL;
141 voidupdateTextBoundsjstringjava_lang_StringID=NULL;
142 voidupdateSubwinScalejstringjava_lang_StringID=NULL;
143 jdoubleArray_get2dViewCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID=NULL;
144 jdoubleArray_getPixelFrom2dViewCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID=NULL;
145 jdoubleArray_get2dViewFromPixelCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID=NULL;
146 jdoubleArray_getViewingAreajstringjava_lang_StringID=NULL;
147
148
149 }
150
151 // Generic methods
152
153 void CallRenderer::synchronize() {
154 if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
155 throw GiwsException::JniMonitorException(getCurrentEnv(), "CallRenderer");
156 }
157 }
158
159 void CallRenderer::endSynchronize() {
160 if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
161 throw GiwsException::JniMonitorException(getCurrentEnv(), "CallRenderer");
162 }
163 }
164 // Method(s)
165
166 void CallRenderer::startInteractiveZoom (JavaVM * jvm_, char const* id){
167
168 JNIEnv * curEnv = NULL;
169 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
170 jclass cls = curEnv->FindClass( className().c_str() );
171
172 jmethodID voidstartInteractiveZoomjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "startInteractiveZoom", "(Ljava/lang/String;)V" ) ;
173 if (voidstartInteractiveZoomjstringjava_lang_StringID == NULL) {
174 throw GiwsException::JniMethodNotFoundException(curEnv, "startInteractiveZoom");
175 }
176
177 jstring id_ = curEnv->NewStringUTF( id );
178 if (id != NULL && id_ == NULL)
179 {
180 throw GiwsException::JniBadAllocException(curEnv);
181 }
182
183
184                          curEnv->CallStaticVoidMethod(cls, voidstartInteractiveZoomjstringjava_lang_StringID ,id_);
185                         curEnv->DeleteLocalRef(id_);
186 curEnv->DeleteLocalRef(cls);
187 if (curEnv->ExceptionCheck()) {
188 throw GiwsException::JniCallMethodException(curEnv);
189 }
190 }
191
192 double* CallRenderer::clickRubberBox (JavaVM * jvm_, char const* id, double const* startRectangle, int startRectangleSize){
193
194 JNIEnv * curEnv = NULL;
195 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
196 jclass cls = curEnv->FindClass( className().c_str() );
197
198 jmethodID jdoubleArray_clickRubberBoxjstringjava_lang_StringjdoubleArray_doubledoubleID = curEnv->GetStaticMethodID(cls, "clickRubberBox", "(Ljava/lang/String;[D)[D" ) ;
199 if (jdoubleArray_clickRubberBoxjstringjava_lang_StringjdoubleArray_doubledoubleID == NULL) {
200 throw GiwsException::JniMethodNotFoundException(curEnv, "clickRubberBox");
201 }
202
203 jstring id_ = curEnv->NewStringUTF( id );
204 if (id != NULL && id_ == NULL)
205 {
206 throw GiwsException::JniBadAllocException(curEnv);
207 }
208
209
210 jdoubleArray startRectangle_ = curEnv->NewDoubleArray( startRectangleSize ) ;
211
212 if (startRectangle_ == NULL)
213 {
214 // check that allocation succeed
215 throw GiwsException::JniBadAllocException(curEnv);
216 }
217
218 curEnv->SetDoubleArrayRegion( startRectangle_, 0, startRectangleSize, (jdouble*)(startRectangle) ) ;
219
220
221                         jdoubleArray res =  static_cast<jdoubleArray>( curEnv->CallStaticObjectMethod(cls, jdoubleArray_clickRubberBoxjstringjava_lang_StringjdoubleArray_doubledoubleID ,id_, startRectangle_));
222                         if (res == NULL) { return NULL; }
223                         if (curEnv->ExceptionCheck()) {
224 throw GiwsException::JniCallMethodException(curEnv);
225 }int lenRow;
226  lenRow = curEnv->GetArrayLength(res);
227 jboolean isCopy = JNI_FALSE;
228
229 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
230 jdouble *resultsArray = static_cast<jdouble *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
231 double* myArray= new double[ lenRow];
232
233 for (jsize i = 0; i <  lenRow; i++){
234 myArray[i]=resultsArray[i];
235 }
236 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
237
238                         curEnv->DeleteLocalRef(res);
239 curEnv->DeleteLocalRef(id_);
240 curEnv->DeleteLocalRef(startRectangle_);
241 curEnv->DeleteLocalRef(cls);
242 if (curEnv->ExceptionCheck()) {
243 delete[] myArray;
244                                 throw GiwsException::JniCallMethodException(curEnv);
245 }
246 return myArray;
247
248 }
249
250 double* CallRenderer::dragRubberBox (JavaVM * jvm_, char const* id){
251
252 JNIEnv * curEnv = NULL;
253 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
254 jclass cls = curEnv->FindClass( className().c_str() );
255
256 jmethodID jdoubleArray_dragRubberBoxjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "dragRubberBox", "(Ljava/lang/String;)[D" ) ;
257 if (jdoubleArray_dragRubberBoxjstringjava_lang_StringID == NULL) {
258 throw GiwsException::JniMethodNotFoundException(curEnv, "dragRubberBox");
259 }
260
261 jstring id_ = curEnv->NewStringUTF( id );
262 if (id != NULL && id_ == NULL)
263 {
264 throw GiwsException::JniBadAllocException(curEnv);
265 }
266
267
268                         jdoubleArray res =  static_cast<jdoubleArray>( curEnv->CallStaticObjectMethod(cls, jdoubleArray_dragRubberBoxjstringjava_lang_StringID ,id_));
269                         if (res == NULL) { return NULL; }
270                         if (curEnv->ExceptionCheck()) {
271 throw GiwsException::JniCallMethodException(curEnv);
272 }int lenRow;
273  lenRow = curEnv->GetArrayLength(res);
274 jboolean isCopy = JNI_FALSE;
275
276 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
277 jdouble *resultsArray = static_cast<jdouble *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
278 double* myArray= new double[ lenRow];
279
280 for (jsize i = 0; i <  lenRow; i++){
281 myArray[i]=resultsArray[i];
282 }
283 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
284
285                         curEnv->DeleteLocalRef(res);
286 curEnv->DeleteLocalRef(id_);
287 curEnv->DeleteLocalRef(cls);
288 if (curEnv->ExceptionCheck()) {
289 delete[] myArray;
290                                 throw GiwsException::JniCallMethodException(curEnv);
291 }
292 return myArray;
293
294 }
295
296 void CallRenderer::updateTextBounds (JavaVM * jvm_, char const* id){
297
298 JNIEnv * curEnv = NULL;
299 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
300 jclass cls = curEnv->FindClass( className().c_str() );
301
302 jmethodID voidupdateTextBoundsjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "updateTextBounds", "(Ljava/lang/String;)V" ) ;
303 if (voidupdateTextBoundsjstringjava_lang_StringID == NULL) {
304 throw GiwsException::JniMethodNotFoundException(curEnv, "updateTextBounds");
305 }
306
307 jstring id_ = curEnv->NewStringUTF( id );
308 if (id != NULL && id_ == NULL)
309 {
310 throw GiwsException::JniBadAllocException(curEnv);
311 }
312
313
314                          curEnv->CallStaticVoidMethod(cls, voidupdateTextBoundsjstringjava_lang_StringID ,id_);
315                         curEnv->DeleteLocalRef(id_);
316 curEnv->DeleteLocalRef(cls);
317 if (curEnv->ExceptionCheck()) {
318 throw GiwsException::JniCallMethodException(curEnv);
319 }
320 }
321
322 void CallRenderer::updateSubwinScale (JavaVM * jvm_, char const* id){
323
324 JNIEnv * curEnv = NULL;
325 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
326 jclass cls = curEnv->FindClass( className().c_str() );
327
328 jmethodID voidupdateSubwinScalejstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "updateSubwinScale", "(Ljava/lang/String;)V" ) ;
329 if (voidupdateSubwinScalejstringjava_lang_StringID == NULL) {
330 throw GiwsException::JniMethodNotFoundException(curEnv, "updateSubwinScale");
331 }
332
333 jstring id_ = curEnv->NewStringUTF( id );
334 if (id != NULL && id_ == NULL)
335 {
336 throw GiwsException::JniBadAllocException(curEnv);
337 }
338
339
340                          curEnv->CallStaticVoidMethod(cls, voidupdateSubwinScalejstringjava_lang_StringID ,id_);
341                         curEnv->DeleteLocalRef(id_);
342 curEnv->DeleteLocalRef(cls);
343 if (curEnv->ExceptionCheck()) {
344 throw GiwsException::JniCallMethodException(curEnv);
345 }
346 }
347
348 double* CallRenderer::get2dViewCoordinates (JavaVM * jvm_, char const* id, double const* coords, int coordsSize){
349
350 JNIEnv * curEnv = NULL;
351 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
352 jclass cls = curEnv->FindClass( className().c_str() );
353
354 jmethodID jdoubleArray_get2dViewCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID = curEnv->GetStaticMethodID(cls, "get2dViewCoordinates", "(Ljava/lang/String;[D)[D" ) ;
355 if (jdoubleArray_get2dViewCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID == NULL) {
356 throw GiwsException::JniMethodNotFoundException(curEnv, "get2dViewCoordinates");
357 }
358
359 jstring id_ = curEnv->NewStringUTF( id );
360 if (id != NULL && id_ == NULL)
361 {
362 throw GiwsException::JniBadAllocException(curEnv);
363 }
364
365
366 jdoubleArray coords_ = curEnv->NewDoubleArray( coordsSize ) ;
367
368 if (coords_ == NULL)
369 {
370 // check that allocation succeed
371 throw GiwsException::JniBadAllocException(curEnv);
372 }
373
374 curEnv->SetDoubleArrayRegion( coords_, 0, coordsSize, (jdouble*)(coords) ) ;
375
376
377                         jdoubleArray res =  static_cast<jdoubleArray>( curEnv->CallStaticObjectMethod(cls, jdoubleArray_get2dViewCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID ,id_, coords_));
378                         if (res == NULL) { return NULL; }
379                         if (curEnv->ExceptionCheck()) {
380 throw GiwsException::JniCallMethodException(curEnv);
381 }int lenRow;
382  lenRow = curEnv->GetArrayLength(res);
383 jboolean isCopy = JNI_FALSE;
384
385 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
386 jdouble *resultsArray = static_cast<jdouble *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
387 double* myArray= new double[ lenRow];
388
389 for (jsize i = 0; i <  lenRow; i++){
390 myArray[i]=resultsArray[i];
391 }
392 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
393
394                         curEnv->DeleteLocalRef(res);
395 curEnv->DeleteLocalRef(id_);
396 curEnv->DeleteLocalRef(coords_);
397 curEnv->DeleteLocalRef(cls);
398 if (curEnv->ExceptionCheck()) {
399 delete[] myArray;
400                                 throw GiwsException::JniCallMethodException(curEnv);
401 }
402 return myArray;
403
404 }
405
406 double* CallRenderer::getPixelFrom2dViewCoordinates (JavaVM * jvm_, char const* id, double const* coords, int coordsSize){
407
408 JNIEnv * curEnv = NULL;
409 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
410 jclass cls = curEnv->FindClass( className().c_str() );
411
412 jmethodID jdoubleArray_getPixelFrom2dViewCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID = curEnv->GetStaticMethodID(cls, "getPixelFrom2dViewCoordinates", "(Ljava/lang/String;[D)[D" ) ;
413 if (jdoubleArray_getPixelFrom2dViewCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID == NULL) {
414 throw GiwsException::JniMethodNotFoundException(curEnv, "getPixelFrom2dViewCoordinates");
415 }
416
417 jstring id_ = curEnv->NewStringUTF( id );
418 if (id != NULL && id_ == NULL)
419 {
420 throw GiwsException::JniBadAllocException(curEnv);
421 }
422
423
424 jdoubleArray coords_ = curEnv->NewDoubleArray( coordsSize ) ;
425
426 if (coords_ == NULL)
427 {
428 // check that allocation succeed
429 throw GiwsException::JniBadAllocException(curEnv);
430 }
431
432 curEnv->SetDoubleArrayRegion( coords_, 0, coordsSize, (jdouble*)(coords) ) ;
433
434
435                         jdoubleArray res =  static_cast<jdoubleArray>( curEnv->CallStaticObjectMethod(cls, jdoubleArray_getPixelFrom2dViewCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID ,id_, coords_));
436                         if (res == NULL) { return NULL; }
437                         if (curEnv->ExceptionCheck()) {
438 throw GiwsException::JniCallMethodException(curEnv);
439 }int lenRow;
440  lenRow = curEnv->GetArrayLength(res);
441 jboolean isCopy = JNI_FALSE;
442
443 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
444 jdouble *resultsArray = static_cast<jdouble *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
445 double* myArray= new double[ lenRow];
446
447 for (jsize i = 0; i <  lenRow; i++){
448 myArray[i]=resultsArray[i];
449 }
450 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
451
452                         curEnv->DeleteLocalRef(res);
453 curEnv->DeleteLocalRef(id_);
454 curEnv->DeleteLocalRef(coords_);
455 curEnv->DeleteLocalRef(cls);
456 if (curEnv->ExceptionCheck()) {
457 delete[] myArray;
458                                 throw GiwsException::JniCallMethodException(curEnv);
459 }
460 return myArray;
461
462 }
463
464 double* CallRenderer::get2dViewFromPixelCoordinates (JavaVM * jvm_, char const* id, double const* coords, int coordsSize){
465
466 JNIEnv * curEnv = NULL;
467 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
468 jclass cls = curEnv->FindClass( className().c_str() );
469
470 jmethodID jdoubleArray_get2dViewFromPixelCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID = curEnv->GetStaticMethodID(cls, "get2dViewFromPixelCoordinates", "(Ljava/lang/String;[D)[D" ) ;
471 if (jdoubleArray_get2dViewFromPixelCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID == NULL) {
472 throw GiwsException::JniMethodNotFoundException(curEnv, "get2dViewFromPixelCoordinates");
473 }
474
475 jstring id_ = curEnv->NewStringUTF( id );
476 if (id != NULL && id_ == NULL)
477 {
478 throw GiwsException::JniBadAllocException(curEnv);
479 }
480
481
482 jdoubleArray coords_ = curEnv->NewDoubleArray( coordsSize ) ;
483
484 if (coords_ == NULL)
485 {
486 // check that allocation succeed
487 throw GiwsException::JniBadAllocException(curEnv);
488 }
489
490 curEnv->SetDoubleArrayRegion( coords_, 0, coordsSize, (jdouble*)(coords) ) ;
491
492
493                         jdoubleArray res =  static_cast<jdoubleArray>( curEnv->CallStaticObjectMethod(cls, jdoubleArray_get2dViewFromPixelCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID ,id_, coords_));
494                         if (res == NULL) { return NULL; }
495                         if (curEnv->ExceptionCheck()) {
496 throw GiwsException::JniCallMethodException(curEnv);
497 }int lenRow;
498  lenRow = curEnv->GetArrayLength(res);
499 jboolean isCopy = JNI_FALSE;
500
501 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
502 jdouble *resultsArray = static_cast<jdouble *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
503 double* myArray= new double[ lenRow];
504
505 for (jsize i = 0; i <  lenRow; i++){
506 myArray[i]=resultsArray[i];
507 }
508 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
509
510                         curEnv->DeleteLocalRef(res);
511 curEnv->DeleteLocalRef(id_);
512 curEnv->DeleteLocalRef(coords_);
513 curEnv->DeleteLocalRef(cls);
514 if (curEnv->ExceptionCheck()) {
515 delete[] myArray;
516                                 throw GiwsException::JniCallMethodException(curEnv);
517 }
518 return myArray;
519
520 }
521
522 double* CallRenderer::getViewingArea (JavaVM * jvm_, char const* id){
523
524 JNIEnv * curEnv = NULL;
525 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
526 jclass cls = curEnv->FindClass( className().c_str() );
527
528 jmethodID jdoubleArray_getViewingAreajstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "getViewingArea", "(Ljava/lang/String;)[D" ) ;
529 if (jdoubleArray_getViewingAreajstringjava_lang_StringID == NULL) {
530 throw GiwsException::JniMethodNotFoundException(curEnv, "getViewingArea");
531 }
532
533 jstring id_ = curEnv->NewStringUTF( id );
534 if (id != NULL && id_ == NULL)
535 {
536 throw GiwsException::JniBadAllocException(curEnv);
537 }
538
539
540                         jdoubleArray res =  static_cast<jdoubleArray>( curEnv->CallStaticObjectMethod(cls, jdoubleArray_getViewingAreajstringjava_lang_StringID ,id_));
541                         if (res == NULL) { return NULL; }
542                         if (curEnv->ExceptionCheck()) {
543 throw GiwsException::JniCallMethodException(curEnv);
544 }int lenRow;
545  lenRow = curEnv->GetArrayLength(res);
546 jboolean isCopy = JNI_FALSE;
547
548 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
549 jdouble *resultsArray = static_cast<jdouble *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
550 double* myArray= new double[ lenRow];
551
552 for (jsize i = 0; i <  lenRow; i++){
553 myArray[i]=resultsArray[i];
554 }
555 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
556
557                         curEnv->DeleteLocalRef(res);
558 curEnv->DeleteLocalRef(id_);
559 curEnv->DeleteLocalRef(cls);
560 if (curEnv->ExceptionCheck()) {
561 delete[] myArray;
562                                 throw GiwsException::JniCallMethodException(curEnv);
563 }
564 return myArray;
565
566 }
567
568 }