scilab/modules/ui_data/src/jni/BrowseVar.cpp

   1 #include "BrowseVar.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/BrowseVar.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_ui_data {
  40
  41                 // Static declarations (if any)
  42
  43 // Returns the current env
  44
  45 JNIEnv * BrowseVar::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 BrowseVar::~BrowseVar() {
  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 curEnv->DeleteGlobalRef(this->stringArrayClass);}
  62 // Constructors
  63 BrowseVar::BrowseVar(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 voidopenVariableBrowserjbooleanbooleanjobjectArray_java_lang_Stringjava_lang_StringjintArray_intintjintArray_intintjintArray_intintjobjectArray_java_lang_Stringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringjintArray_intintjintArray_intintjobjectArray_java_lang_Stringjava_lang_StringjbooleanArray_booleanbooleanID=NULL;
 108 jbooleanisVariableBrowserOpenedID=NULL;
 109 voidcloseVariableBrowserID=NULL;
 110
 111
 112 }
 113
 114 BrowseVar::BrowseVar(JavaVM * jvm_, jobject JObj) {
 115         jvm=jvm_;
 116
 117         JNIEnv * curEnv = getCurrentEnv();
 118
 119 jclass localClass = curEnv->GetObjectClass(JObj);
 120         this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
 121         curEnv->DeleteLocalRef(localClass);
 122
 123         if (this->instanceClass == NULL) {
 124 throw GiwsException::JniObjectCreationException(curEnv, this->className());
 125         }
 126
 127         this->instance = curEnv->NewGlobalRef(JObj) ;
 128         if(this->instance == NULL){
 129 throw GiwsException::JniObjectCreationException(curEnv, this->className());
 130         }
 131         /* Methods ID set to NULL */
 132         voidopenVariableBrowserjbooleanbooleanjobjectArray_java_lang_Stringjava_lang_StringjintArray_intintjintArray_intintjintArray_intintjobjectArray_java_lang_Stringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringjintArray_intintjintArray_intintjobjectArray_java_lang_Stringjava_lang_StringjbooleanArray_booleanbooleanID=NULL;
 133 jbooleanisVariableBrowserOpenedID=NULL;
 134 voidcloseVariableBrowserID=NULL;
 135
 136
 137 }
 138
 139 // Generic methods
 140
 141 void BrowseVar::synchronize() {
 142 if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
 143 throw GiwsException::JniMonitorException(getCurrentEnv(), "BrowseVar");
 144 }
 145 }
 146
 147 void BrowseVar::endSynchronize() {
 148 if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
 149 throw GiwsException::JniMonitorException(getCurrentEnv(), "BrowseVar");
 150 }
 151 }
 152 // Method(s)
 153
 154 void BrowseVar::openVariableBrowser (JavaVM * jvm_, bool update, char const* const* variableNames, int variableNamesSize, int const* variableBytes, int variableBytesSize, int const* variableTypes, int variableTypesSize, int const* variableIntegerTypes, int variableIntegerTypesSize, char const* const* variableListTypes, int variableListTypesSize, char const* const* variableSize, int variableSizeSize, int const* variableNbRows, int variableNbRowsSize, int const* variableNbCols, int variableNbColsSize, char const* const* variableVisibility, int variableVisibilitySize, bool const* variableFromUser, int variableFromUserSize){
 155
 156 JNIEnv * curEnv = NULL;
 157 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
 158 jclass cls = curEnv->FindClass( className().c_str() );
 159
 160 jmethodID voidopenVariableBrowserjbooleanbooleanjobjectArray_java_lang_Stringjava_lang_StringjintArray_intintjintArray_intintjintArray_intintjobjectArray_java_lang_Stringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringjintArray_intintjintArray_intintjobjectArray_java_lang_Stringjava_lang_StringjbooleanArray_booleanbooleanID = curEnv->GetStaticMethodID(cls, "openVariableBrowser", "(Z[Ljava/lang/String;[I[I[I[Ljava/lang/String;[Ljava/lang/String;[I[I[Ljava/lang/String;[Z)V" ) ;
 161 if (voidopenVariableBrowserjbooleanbooleanjobjectArray_java_lang_Stringjava_lang_StringjintArray_intintjintArray_intintjintArray_intintjobjectArray_java_lang_Stringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringjintArray_intintjintArray_intintjobjectArray_java_lang_Stringjava_lang_StringjbooleanArray_booleanbooleanID == NULL) {
 162 throw GiwsException::JniMethodNotFoundException(curEnv, "openVariableBrowser");
 163 }
 164
 165 jboolean update_ = (static_cast<bool>(update) ? JNI_TRUE : JNI_FALSE);
 166 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
 167
 168 // create java array of strings.
 169 jobjectArray variableNames_ = curEnv->NewObjectArray( variableNamesSize, stringArrayClass, NULL);
 170 if (variableNames_ == NULL)
 171 {
 172 throw GiwsException::JniBadAllocException(curEnv);
 173 }
 174
 175 // convert each char * to java strings and fill the java array.
 176 for ( int i = 0; i < variableNamesSize; i++)
 177 {
 178 jstring TempString = curEnv->NewStringUTF( variableNames[i] );
 179 if (TempString == NULL)
 180 {
 181 throw GiwsException::JniBadAllocException(curEnv);
 182 }
 183
 184 curEnv->SetObjectArrayElement( variableNames_, i, TempString);
 185
 186 // avoid keeping reference on to many strings
 187 curEnv->DeleteLocalRef(TempString);
 188 }
 189 jintArray variableBytes_ = curEnv->NewIntArray( variableBytesSize ) ;
 190
 191 if (variableBytes_ == NULL)
 192 {
 193 // check that allocation succeed
 194 throw GiwsException::JniBadAllocException(curEnv);
 195 }
 196
 197 curEnv->SetIntArrayRegion( variableBytes_, 0, variableBytesSize, (jint*)(variableBytes) ) ;
 198
 199
 200 jintArray variableTypes_ = curEnv->NewIntArray( variableTypesSize ) ;
 201
 202 if (variableTypes_ == NULL)
 203 {
 204 // check that allocation succeed
 205 throw GiwsException::JniBadAllocException(curEnv);
 206 }
 207
 208 curEnv->SetIntArrayRegion( variableTypes_, 0, variableTypesSize, (jint*)(variableTypes) ) ;
 209
 210
 211 jintArray variableIntegerTypes_ = curEnv->NewIntArray( variableIntegerTypesSize ) ;
 212
 213 if (variableIntegerTypes_ == NULL)
 214 {
 215 // check that allocation succeed
 216 throw GiwsException::JniBadAllocException(curEnv);
 217 }
 218
 219 curEnv->SetIntArrayRegion( variableIntegerTypes_, 0, variableIntegerTypesSize, (jint*)(variableIntegerTypes) ) ;
 220
 221
 222
 223 // create java array of strings.
 224 jobjectArray variableListTypes_ = curEnv->NewObjectArray( variableListTypesSize, stringArrayClass, NULL);
 225 if (variableListTypes_ == NULL)
 226 {
 227 throw GiwsException::JniBadAllocException(curEnv);
 228 }
 229
 230 // convert each char * to java strings and fill the java array.
 231 for ( int i = 0; i < variableListTypesSize; i++)
 232 {
 233 jstring TempString = curEnv->NewStringUTF( variableListTypes[i] );
 234 if (TempString == NULL)
 235 {
 236 throw GiwsException::JniBadAllocException(curEnv);
 237 }
 238
 239 curEnv->SetObjectArrayElement( variableListTypes_, i, TempString);
 240
 241 // avoid keeping reference on to many strings
 242 curEnv->DeleteLocalRef(TempString);
 243 }
 244
 245 // create java array of strings.
 246 jobjectArray variableSize_ = curEnv->NewObjectArray( variableSizeSize, stringArrayClass, NULL);
 247 if (variableSize_ == NULL)
 248 {
 249 throw GiwsException::JniBadAllocException(curEnv);
 250 }
 251
 252 // convert each char * to java strings and fill the java array.
 253 for ( int i = 0; i < variableSizeSize; i++)
 254 {
 255 jstring TempString = curEnv->NewStringUTF( variableSize[i] );
 256 if (TempString == NULL)
 257 {
 258 throw GiwsException::JniBadAllocException(curEnv);
 259 }
 260
 261 curEnv->SetObjectArrayElement( variableSize_, i, TempString);
 262
 263 // avoid keeping reference on to many strings
 264 curEnv->DeleteLocalRef(TempString);
 265 }
 266 jintArray variableNbRows_ = curEnv->NewIntArray( variableNbRowsSize ) ;
 267
 268 if (variableNbRows_ == NULL)
 269 {
 270 // check that allocation succeed
 271 throw GiwsException::JniBadAllocException(curEnv);
 272 }
 273
 274 curEnv->SetIntArrayRegion( variableNbRows_, 0, variableNbRowsSize, (jint*)(variableNbRows) ) ;
 275
 276
 277 jintArray variableNbCols_ = curEnv->NewIntArray( variableNbColsSize ) ;
 278
 279 if (variableNbCols_ == NULL)
 280 {
 281 // check that allocation succeed
 282 throw GiwsException::JniBadAllocException(curEnv);
 283 }
 284
 285 curEnv->SetIntArrayRegion( variableNbCols_, 0, variableNbColsSize, (jint*)(variableNbCols) ) ;
 286
 287
 288
 289 // create java array of strings.
 290 jobjectArray variableVisibility_ = curEnv->NewObjectArray( variableVisibilitySize, stringArrayClass, NULL);
 291 if (variableVisibility_ == NULL)
 292 {
 293 throw GiwsException::JniBadAllocException(curEnv);
 294 }
 295
 296 // convert each char * to java strings and fill the java array.
 297 for ( int i = 0; i < variableVisibilitySize; i++)
 298 {
 299 jstring TempString = curEnv->NewStringUTF( variableVisibility[i] );
 300 if (TempString == NULL)
 301 {
 302 throw GiwsException::JniBadAllocException(curEnv);
 303 }
 304
 305 curEnv->SetObjectArrayElement( variableVisibility_, i, TempString);
 306
 307 // avoid keeping reference on to many strings
 308 curEnv->DeleteLocalRef(TempString);
 309 }
 310 jbooleanArray variableFromUser_ = curEnv->NewBooleanArray( variableFromUserSize ) ;
 311 curEnv->SetBooleanArrayRegion( variableFromUser_, 0, variableFromUserSize, (jboolean*)variableFromUser ) ;
 312
 313                          curEnv->CallStaticVoidMethod(cls, voidopenVariableBrowserjbooleanbooleanjobjectArray_java_lang_Stringjava_lang_StringjintArray_intintjintArray_intintjintArray_intintjobjectArray_java_lang_Stringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringjintArray_intintjintArray_intintjobjectArray_java_lang_Stringjava_lang_StringjbooleanArray_booleanbooleanID ,update_, variableNames_, variableBytes_, variableTypes_, variableIntegerTypes_, variableListTypes_, variableSize_, variableNbRows_, variableNbCols_, variableVisibility_, variableFromUser_);
 314                         curEnv->DeleteLocalRef(stringArrayClass);
 315 curEnv->DeleteLocalRef(variableNames_);
 316 curEnv->DeleteLocalRef(variableBytes_);
 317 curEnv->DeleteLocalRef(variableTypes_);
 318 curEnv->DeleteLocalRef(variableIntegerTypes_);
 319 curEnv->DeleteLocalRef(variableListTypes_);
 320 curEnv->DeleteLocalRef(variableSize_);
 321 curEnv->DeleteLocalRef(variableNbRows_);
 322 curEnv->DeleteLocalRef(variableNbCols_);
 323 curEnv->DeleteLocalRef(variableVisibility_);
 324 curEnv->DeleteLocalRef(variableFromUser_);
 325 curEnv->DeleteLocalRef(cls);
 326 if (curEnv->ExceptionCheck()) {
 327 throw GiwsException::JniCallMethodException(curEnv);
 328 }
 329 }
 330
 331 bool BrowseVar::isVariableBrowserOpened (JavaVM * jvm_){
 332
 333 JNIEnv * curEnv = NULL;
 334 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
 335 jclass cls = curEnv->FindClass( className().c_str() );
 336
 337 jmethodID jbooleanisVariableBrowserOpenedID = curEnv->GetStaticMethodID(cls, "isVariableBrowserOpened", "()Z" ) ;
 338 if (jbooleanisVariableBrowserOpenedID == NULL) {
 339 throw GiwsException::JniMethodNotFoundException(curEnv, "isVariableBrowserOpened");
 340 }
 341
 342                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanisVariableBrowserOpenedID ));
 343                         curEnv->DeleteLocalRef(cls);
 344 if (curEnv->ExceptionCheck()) {
 345 throw GiwsException::JniCallMethodException(curEnv);
 346 }
 347 return (res == JNI_TRUE);
 348
 349 }
 350
 351 void BrowseVar::closeVariableBrowser (JavaVM * jvm_){
 352
 353 JNIEnv * curEnv = NULL;
 354 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
 355 jclass cls = curEnv->FindClass( className().c_str() );
 356
 357 jmethodID voidcloseVariableBrowserID = curEnv->GetStaticMethodID(cls, "closeVariableBrowser", "()V" ) ;
 358 if (voidcloseVariableBrowserID == NULL) {
 359 throw GiwsException::JniMethodNotFoundException(curEnv, "closeVariableBrowser");
 360 }
 361
 362                          curEnv->CallStaticVoidMethod(cls, voidcloseVariableBrowserID );
 363                         curEnv->DeleteLocalRef(cls);
 364 if (curEnv->ExceptionCheck()) {
 365 throw GiwsException::JniCallMethodException(curEnv);
 366 }
 367 }
 368
 369 }