scilab/modules/renderer/src/jni/CallRenderer.cpp

   1 #include "CallRenderer.hxx"
   2 /* Generated by GIWS (version 2.0.0) 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 Copyright 2007-2008 INRIA
   8 Copyright 2008-2011 DIGITEO
   9 Copyright 2011-2012 Scilab Enterprises
  10
  11 Author : Sylvestre Ledru & others
  12
  13 This is generated code.
  14
  15 This software is a computer program whose purpose is to hide the complexity
  16 of accessing Java objects/methods from C++ code.
  17
  18 This software is governed by the CeCILL-B license under French law and
  19 abiding by the rules of distribution of free software.  You can  use,
  20 modify and/ or redistribute the software under the terms of the CeCILL-B
  21 license as circulated by CEA, CNRS and INRIA at the following URL
  22 "http://www.cecill.info".
  23
  24 As a counterpart to the access to the source code and  rights to copy,
  25 modify and redistribute granted by the license, users are provided only
  26 with a limited warranty  and the software's author,  the holder of the
  27 economic rights,  and the successive licensors  have only  limited
  28 liability.
  29
  30 In this respect, the user's attention is drawn to the risks associated
  31 with loading,  using,  modifying and/or developing or reproducing the
  32 software by the user in light of its specific status of free software,
  33 that may mean  that it is complicated to manipulate,  and  that  also
  34 therefore means  that it is reserved for developers  and  experienced
  35 professionals having in-depth computer knowledge. Users are therefore
  36 encouraged to load and test the software's suitability as regards their
  37 requirements in conditions enabling the security of their systems and/or
  38 data to be ensured and,  more generally, to use and operate it in the
  39 same conditions as regards security.
  40
  41 The fact that you are presently reading this means that you have had
  42 knowledge of the CeCILL-B license and that you accept its terms.
  43 */
  44
  45 namespace org_scilab_modules_renderer {
  46
  47                 // Static declarations (if any)
  48
  49 // Returns the current env
  50
  51 JNIEnv * CallRenderer::getCurrentEnv() {
  52 JNIEnv * curEnv = NULL;
  53 jint res=this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
  54 if (res != JNI_OK) {
  55 throw GiwsException::JniException(getCurrentEnv());
  56 }
  57 return curEnv;
  58 }
  59 // Destructor
  60
  61 CallRenderer::~CallRenderer() {
  62 JNIEnv * curEnv = NULL;
  63 this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
  64
  65 curEnv->DeleteGlobalRef(this->instance);
  66 curEnv->DeleteGlobalRef(this->instanceClass);
  67 }
  68 // Constructors
  69 CallRenderer::CallRenderer(JavaVM * jvm_) {
  70 jmethodID constructObject = NULL ;
  71 jobject localInstance ;
  72 jclass localClass ;
  73
  74 const std::string construct="<init>";
  75 const std::string param="()V";
  76 jvm=jvm_;
  77
  78 JNIEnv * curEnv = getCurrentEnv();
  79
  80 localClass = curEnv->FindClass( this->className().c_str() ) ;
  81 if (localClass == NULL) {
  82   throw GiwsException::JniClassNotFoundException(curEnv, this->className());
  83 }
  84
  85 this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
  86
  87 /* localClass is not needed anymore */
  88 curEnv->DeleteLocalRef(localClass);
  89
  90 if (this->instanceClass == NULL) {
  91 throw GiwsException::JniObjectCreationException(curEnv, this->className());
  92 }
  93
  94
  95 constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
  96 if(constructObject == NULL){
  97 throw GiwsException::JniObjectCreationException(curEnv, this->className());
  98 }
  99
 100 localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
 101 if(localInstance == NULL){
 102 throw GiwsException::JniObjectCreationException(curEnv, this->className());
 103 }
 104
 105 this->instance = curEnv->NewGlobalRef(localInstance) ;
 106 if(this->instance == NULL){
 107 throw GiwsException::JniObjectCreationException(curEnv, this->className());
 108 }
 109 /* localInstance not needed anymore */
 110 curEnv->DeleteLocalRef(localInstance);
 111
 112                 /* Methods ID set to NULL */
 113 voidstartInteractiveZoomjstringjava_lang_StringID=NULL;
 114 voidupdateTextBoundsjstringjava_lang_StringID=NULL;
 115 voidupdateSubwinScalejstringjava_lang_StringID=NULL;
 116 jdoubleArray_get2dViewCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID=NULL;
 117 jdoubleArray_getPixelFrom2dViewCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID=NULL;
 118 jdoubleArray_get2dViewFromPixelCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID=NULL;
 119 jdoubleArray_getViewingAreajstringjava_lang_StringID=NULL;
 120
 121
 122 }
 123
 124 CallRenderer::CallRenderer(JavaVM * jvm_, jobject JObj) {
 125         jvm=jvm_;
 126
 127         JNIEnv * curEnv = getCurrentEnv();
 128
 129 jclass localClass = curEnv->GetObjectClass(JObj);
 130         this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
 131         curEnv->DeleteLocalRef(localClass);
 132
 133         if (this->instanceClass == NULL) {
 134 throw GiwsException::JniObjectCreationException(curEnv, this->className());
 135         }
 136
 137         this->instance = curEnv->NewGlobalRef(JObj) ;
 138         if(this->instance == NULL){
 139 throw GiwsException::JniObjectCreationException(curEnv, this->className());
 140         }
 141         /* Methods ID set to NULL */
 142         voidstartInteractiveZoomjstringjava_lang_StringID=NULL;
 143 voidupdateTextBoundsjstringjava_lang_StringID=NULL;
 144 voidupdateSubwinScalejstringjava_lang_StringID=NULL;
 145 jdoubleArray_get2dViewCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID=NULL;
 146 jdoubleArray_getPixelFrom2dViewCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID=NULL;
 147 jdoubleArray_get2dViewFromPixelCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID=NULL;
 148 jdoubleArray_getViewingAreajstringjava_lang_StringID=NULL;
 149
 150
 151 }
 152
 153 // Generic methods
 154
 155 void CallRenderer::synchronize() {
 156 if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
 157 throw GiwsException::JniMonitorException(getCurrentEnv(), "CallRenderer");
 158 }
 159 }
 160
 161 void CallRenderer::endSynchronize() {
 162 if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
 163 throw GiwsException::JniMonitorException(getCurrentEnv(), "CallRenderer");
 164 }
 165 }
 166 // Method(s)
 167
 168 void CallRenderer::startInteractiveZoom (JavaVM * jvm_, char const* id){
 169
 170 JNIEnv * curEnv = NULL;
 171 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
 172 jclass cls = curEnv->FindClass( className().c_str() );
 173
 174 jmethodID voidstartInteractiveZoomjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "startInteractiveZoom", "(Ljava/lang/String;)V" ) ;
 175 if (voidstartInteractiveZoomjstringjava_lang_StringID == NULL) {
 176 throw GiwsException::JniMethodNotFoundException(curEnv, "startInteractiveZoom");
 177 }
 178
 179 jstring id_ = curEnv->NewStringUTF( id );
 180 if (id != NULL && id_ == NULL)
 181 {
 182 throw GiwsException::JniBadAllocException(curEnv);
 183 }
 184
 185
 186                          curEnv->CallStaticVoidMethod(cls, voidstartInteractiveZoomjstringjava_lang_StringID ,id_);
 187                         curEnv->DeleteLocalRef(id_);
 188 curEnv->DeleteLocalRef(cls);
 189 if (curEnv->ExceptionCheck()) {
 190 throw GiwsException::JniCallMethodException(curEnv);
 191 }
 192 }
 193
 194 void CallRenderer::updateTextBounds (JavaVM * jvm_, char const* id){
 195
 196 JNIEnv * curEnv = NULL;
 197 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
 198 jclass cls = curEnv->FindClass( className().c_str() );
 199
 200 jmethodID voidupdateTextBoundsjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "updateTextBounds", "(Ljava/lang/String;)V" ) ;
 201 if (voidupdateTextBoundsjstringjava_lang_StringID == NULL) {
 202 throw GiwsException::JniMethodNotFoundException(curEnv, "updateTextBounds");
 203 }
 204
 205 jstring id_ = curEnv->NewStringUTF( id );
 206 if (id != NULL && id_ == NULL)
 207 {
 208 throw GiwsException::JniBadAllocException(curEnv);
 209 }
 210
 211
 212                          curEnv->CallStaticVoidMethod(cls, voidupdateTextBoundsjstringjava_lang_StringID ,id_);
 213                         curEnv->DeleteLocalRef(id_);
 214 curEnv->DeleteLocalRef(cls);
 215 if (curEnv->ExceptionCheck()) {
 216 throw GiwsException::JniCallMethodException(curEnv);
 217 }
 218 }
 219
 220 void CallRenderer::updateSubwinScale (JavaVM * jvm_, char const* id){
 221
 222 JNIEnv * curEnv = NULL;
 223 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
 224 jclass cls = curEnv->FindClass( className().c_str() );
 225
 226 jmethodID voidupdateSubwinScalejstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "updateSubwinScale", "(Ljava/lang/String;)V" ) ;
 227 if (voidupdateSubwinScalejstringjava_lang_StringID == NULL) {
 228 throw GiwsException::JniMethodNotFoundException(curEnv, "updateSubwinScale");
 229 }
 230
 231 jstring id_ = curEnv->NewStringUTF( id );
 232 if (id != NULL && id_ == NULL)
 233 {
 234 throw GiwsException::JniBadAllocException(curEnv);
 235 }
 236
 237
 238                          curEnv->CallStaticVoidMethod(cls, voidupdateSubwinScalejstringjava_lang_StringID ,id_);
 239                         curEnv->DeleteLocalRef(id_);
 240 curEnv->DeleteLocalRef(cls);
 241 if (curEnv->ExceptionCheck()) {
 242 throw GiwsException::JniCallMethodException(curEnv);
 243 }
 244 }
 245
 246 double* CallRenderer::get2dViewCoordinates (JavaVM * jvm_, char const* id, double const* coords, int coordsSize){
 247
 248 JNIEnv * curEnv = NULL;
 249 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
 250 jclass cls = curEnv->FindClass( className().c_str() );
 251
 252 jmethodID jdoubleArray_get2dViewCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID = curEnv->GetStaticMethodID(cls, "get2dViewCoordinates", "(Ljava/lang/String;[D)[D" ) ;
 253 if (jdoubleArray_get2dViewCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID == NULL) {
 254 throw GiwsException::JniMethodNotFoundException(curEnv, "get2dViewCoordinates");
 255 }
 256
 257 jstring id_ = curEnv->NewStringUTF( id );
 258 if (id != NULL && id_ == NULL)
 259 {
 260 throw GiwsException::JniBadAllocException(curEnv);
 261 }
 262
 263
 264 jdoubleArray coords_ = curEnv->NewDoubleArray( coordsSize ) ;
 265
 266 if (coords_ == NULL)
 267 {
 268 // check that allocation succeed
 269 throw GiwsException::JniBadAllocException(curEnv);
 270 }
 271
 272 curEnv->SetDoubleArrayRegion( coords_, 0, coordsSize, (jdouble*)(coords) ) ;
 273
 274
 275                         jdoubleArray res =  static_cast<jdoubleArray>( curEnv->CallStaticObjectMethod(cls, jdoubleArray_get2dViewCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID ,id_, coords_));
 276                         if (res == NULL) { return NULL; }
 277                         if (curEnv->ExceptionCheck()) {
 278 throw GiwsException::JniCallMethodException(curEnv);
 279 }int lenRow;
 280  lenRow = curEnv->GetArrayLength(res);
 281 jboolean isCopy = JNI_FALSE;
 282
 283 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
 284 jdouble *resultsArray = static_cast<jdouble *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
 285 double* myArray= new double[ lenRow];
 286
 287 for (jsize i = 0; i <  lenRow; i++){
 288 myArray[i]=resultsArray[i];
 289 }
 290 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
 291
 292                         curEnv->DeleteLocalRef(res);
 293 curEnv->DeleteLocalRef(id_);
 294 curEnv->DeleteLocalRef(coords_);
 295 curEnv->DeleteLocalRef(cls);
 296 if (curEnv->ExceptionCheck()) {
 297 delete[] myArray;
 298                                 throw GiwsException::JniCallMethodException(curEnv);
 299 }
 300 return myArray;
 301
 302 }
 303
 304 double* CallRenderer::getPixelFrom2dViewCoordinates (JavaVM * jvm_, char const* id, double const* coords, int coordsSize){
 305
 306 JNIEnv * curEnv = NULL;
 307 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
 308 jclass cls = curEnv->FindClass( className().c_str() );
 309
 310 jmethodID jdoubleArray_getPixelFrom2dViewCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID = curEnv->GetStaticMethodID(cls, "getPixelFrom2dViewCoordinates", "(Ljava/lang/String;[D)[D" ) ;
 311 if (jdoubleArray_getPixelFrom2dViewCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID == NULL) {
 312 throw GiwsException::JniMethodNotFoundException(curEnv, "getPixelFrom2dViewCoordinates");
 313 }
 314
 315 jstring id_ = curEnv->NewStringUTF( id );
 316 if (id != NULL && id_ == NULL)
 317 {
 318 throw GiwsException::JniBadAllocException(curEnv);
 319 }
 320
 321
 322 jdoubleArray coords_ = curEnv->NewDoubleArray( coordsSize ) ;
 323
 324 if (coords_ == NULL)
 325 {
 326 // check that allocation succeed
 327 throw GiwsException::JniBadAllocException(curEnv);
 328 }
 329
 330 curEnv->SetDoubleArrayRegion( coords_, 0, coordsSize, (jdouble*)(coords) ) ;
 331
 332
 333                         jdoubleArray res =  static_cast<jdoubleArray>( curEnv->CallStaticObjectMethod(cls, jdoubleArray_getPixelFrom2dViewCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID ,id_, coords_));
 334                         if (res == NULL) { return NULL; }
 335                         if (curEnv->ExceptionCheck()) {
 336 throw GiwsException::JniCallMethodException(curEnv);
 337 }int lenRow;
 338  lenRow = curEnv->GetArrayLength(res);
 339 jboolean isCopy = JNI_FALSE;
 340
 341 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
 342 jdouble *resultsArray = static_cast<jdouble *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
 343 double* myArray= new double[ lenRow];
 344
 345 for (jsize i = 0; i <  lenRow; i++){
 346 myArray[i]=resultsArray[i];
 347 }
 348 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
 349
 350                         curEnv->DeleteLocalRef(res);
 351 curEnv->DeleteLocalRef(id_);
 352 curEnv->DeleteLocalRef(coords_);
 353 curEnv->DeleteLocalRef(cls);
 354 if (curEnv->ExceptionCheck()) {
 355 delete[] myArray;
 356                                 throw GiwsException::JniCallMethodException(curEnv);
 357 }
 358 return myArray;
 359
 360 }
 361
 362 double* CallRenderer::get2dViewFromPixelCoordinates (JavaVM * jvm_, char const* id, double const* coords, int coordsSize){
 363
 364 JNIEnv * curEnv = NULL;
 365 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
 366 jclass cls = curEnv->FindClass( className().c_str() );
 367
 368 jmethodID jdoubleArray_get2dViewFromPixelCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID = curEnv->GetStaticMethodID(cls, "get2dViewFromPixelCoordinates", "(Ljava/lang/String;[D)[D" ) ;
 369 if (jdoubleArray_get2dViewFromPixelCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID == NULL) {
 370 throw GiwsException::JniMethodNotFoundException(curEnv, "get2dViewFromPixelCoordinates");
 371 }
 372
 373 jstring id_ = curEnv->NewStringUTF( id );
 374 if (id != NULL && id_ == NULL)
 375 {
 376 throw GiwsException::JniBadAllocException(curEnv);
 377 }
 378
 379
 380 jdoubleArray coords_ = curEnv->NewDoubleArray( coordsSize ) ;
 381
 382 if (coords_ == NULL)
 383 {
 384 // check that allocation succeed
 385 throw GiwsException::JniBadAllocException(curEnv);
 386 }
 387
 388 curEnv->SetDoubleArrayRegion( coords_, 0, coordsSize, (jdouble*)(coords) ) ;
 389
 390
 391                         jdoubleArray res =  static_cast<jdoubleArray>( curEnv->CallStaticObjectMethod(cls, jdoubleArray_get2dViewFromPixelCoordinatesjstringjava_lang_StringjdoubleArray_doubledoubleID ,id_, coords_));
 392                         if (res == NULL) { return NULL; }
 393                         if (curEnv->ExceptionCheck()) {
 394 throw GiwsException::JniCallMethodException(curEnv);
 395 }int lenRow;
 396  lenRow = curEnv->GetArrayLength(res);
 397 jboolean isCopy = JNI_FALSE;
 398
 399 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
 400 jdouble *resultsArray = static_cast<jdouble *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
 401 double* myArray= new double[ lenRow];
 402
 403 for (jsize i = 0; i <  lenRow; i++){
 404 myArray[i]=resultsArray[i];
 405 }
 406 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
 407
 408                         curEnv->DeleteLocalRef(res);
 409 curEnv->DeleteLocalRef(id_);
 410 curEnv->DeleteLocalRef(coords_);
 411 curEnv->DeleteLocalRef(cls);
 412 if (curEnv->ExceptionCheck()) {
 413 delete[] myArray;
 414                                 throw GiwsException::JniCallMethodException(curEnv);
 415 }
 416 return myArray;
 417
 418 }
 419
 420 double* CallRenderer::getViewingArea (JavaVM * jvm_, char const* id){
 421
 422 JNIEnv * curEnv = NULL;
 423 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
 424 jclass cls = curEnv->FindClass( className().c_str() );
 425
 426 jmethodID jdoubleArray_getViewingAreajstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "getViewingArea", "(Ljava/lang/String;)[D" ) ;
 427 if (jdoubleArray_getViewingAreajstringjava_lang_StringID == NULL) {
 428 throw GiwsException::JniMethodNotFoundException(curEnv, "getViewingArea");
 429 }
 430
 431 jstring id_ = curEnv->NewStringUTF( id );
 432 if (id != NULL && id_ == NULL)
 433 {
 434 throw GiwsException::JniBadAllocException(curEnv);
 435 }
 436
 437
 438                         jdoubleArray res =  static_cast<jdoubleArray>( curEnv->CallStaticObjectMethod(cls, jdoubleArray_getViewingAreajstringjava_lang_StringID ,id_));
 439                         if (res == NULL) { return NULL; }
 440                         if (curEnv->ExceptionCheck()) {
 441 throw GiwsException::JniCallMethodException(curEnv);
 442 }int lenRow;
 443  lenRow = curEnv->GetArrayLength(res);
 444 jboolean isCopy = JNI_FALSE;
 445
 446 /* GetPrimitiveArrayCritical is faster than getXXXArrayElements */
 447 jdouble *resultsArray = static_cast<jdouble *>(curEnv->GetPrimitiveArrayCritical(res, &isCopy));
 448 double* myArray= new double[ lenRow];
 449
 450 for (jsize i = 0; i <  lenRow; i++){
 451 myArray[i]=resultsArray[i];
 452 }
 453 curEnv->ReleasePrimitiveArrayCritical(res, resultsArray, JNI_ABORT);
 454
 455                         curEnv->DeleteLocalRef(res);
 456 curEnv->DeleteLocalRef(id_);
 457 curEnv->DeleteLocalRef(cls);
 458 if (curEnv->ExceptionCheck()) {
 459 delete[] myArray;
 460                                 throw GiwsException::JniCallMethodException(curEnv);
 461 }
 462 return myArray;
 463
 464 }
 465
 466 }