EOJ: incorrect giws file after jcreatejar introduction 32/13132/2
Calixte DENIZET [Tue, 12 Nov 2013 12:39:34 +0000 (13:39 +0100)]
Change-Id: I5c38d2a94a1163e6fca95d38976ae5223567c113

scilab/modules/external_objects_java/src/jni/ScilabJarCreator.cpp
scilab/modules/external_objects_java/src/jni/ScilabJarCreator.hxx
scilab/modules/external_objects_java/src/jni/ScilabJavaCompiler.cpp
scilab/modules/external_objects_java/src/jni/ScilabJavaObject.cpp
scilab/modules/external_objects_java/src/jni/ScilabJavaObject.hxx
scilab/modules/external_objects_java/src/jni/ScilabObjects.giws.xml
scilab/modules/external_objects_java/src/jni/ScilabOperations.cpp
scilab/modules/external_objects_java/src/jni/ScilabOperations.hxx

index c577799..1cb1564 100644 (file)
@@ -1,6 +1,6 @@
 #include "ScilabJarCreator.hxx"
-/* Generated by GIWS (version 2.0.1) with command:
-giws -e -f ScilabObjects.giws.xml
+/* Generated by GIWS (version 2.0.2) with command:
+giws -e -f ScilabObjects.giws.xml 
 */
 /*
 
@@ -36,205 +36,186 @@ The fact that you are presently reading this means that you have had
 knowledge of the CeCILL-B license and that you accept its terms.
 */
 
-namespace org_scilab_modules_external_objects_java
-{
-
-// Static declarations (if any)
+namespace org_scilab_modules_external_objects_java {
 
+                // Static declarations (if any)
+                
 // Returns the current env
 
-JNIEnv * ScilabJarCreator::getCurrentEnv()
-{
-    JNIEnv * curEnv = NULL;
-    jint res = this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    if (res != JNI_OK)
-    {
-        throw GiwsException::JniException(getCurrentEnv());
-    }
-    return curEnv;
+JNIEnv * ScilabJarCreator::getCurrentEnv() {
+JNIEnv * curEnv = NULL;
+jint res=this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+if (res != JNI_OK) {
+throw GiwsException::JniException(getCurrentEnv());
+}
+return curEnv;
 }
 // Destructor
 
-ScilabJarCreator::~ScilabJarCreator()
-{
-    JNIEnv * curEnv = NULL;
-    this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+ScilabJarCreator::~ScilabJarCreator() {
+JNIEnv * curEnv = NULL;
+this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+curEnv->DeleteGlobalRef(this->instance);
+curEnv->DeleteGlobalRef(this->instanceClass);
+curEnv->DeleteGlobalRef(this->stringArrayClass);}
+// Constructors
+ScilabJarCreator::ScilabJarCreator(JavaVM * jvm_) {
+jmethodID constructObject = NULL ;
+jobject localInstance ;
+jclass localClass ;
 
-    curEnv->DeleteGlobalRef(this->instance);
-    curEnv->DeleteGlobalRef(this->instanceClass);
-    curEnv->DeleteGlobalRef(this->stringArrayClass);
+const std::string construct="<init>";
+const std::string param="()V";
+jvm=jvm_;
+
+JNIEnv * curEnv = getCurrentEnv();
+
+localClass = curEnv->FindClass( this->className().c_str() ) ;
+if (localClass == NULL) {
+  throw GiwsException::JniClassNotFoundException(curEnv, this->className());
 }
-// Constructors
-ScilabJarCreator::ScilabJarCreator(JavaVM * jvm_)
-{
-    jmethodID constructObject = NULL ;
-    jobject localInstance ;
-    jclass localClass ;
 
-    const std::string construct = "<init>";
-    const std::string param = "()V";
-    jvm = jvm_;
+this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+
+/* localClass is not needed anymore */
+curEnv->DeleteLocalRef(localClass);
 
-    JNIEnv * curEnv = getCurrentEnv();
+if (this->instanceClass == NULL) {
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    localClass = curEnv->FindClass( this->className().c_str() ) ;
-    if (localClass == NULL)
-    {
-        throw GiwsException::JniClassNotFoundException(curEnv, this->className());
-    }
 
-    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
+if(constructObject == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    /* localClass is not needed anymore */
-    curEnv->DeleteLocalRef(localClass);
+localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
+if(localInstance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+this->instance = curEnv->NewGlobalRef(localInstance) ;
+if(this->instance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+/* localInstance not needed anymore */
+curEnv->DeleteLocalRef(localInstance);
 
-    if (this->instanceClass == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+                /* Methods ID set to NULL */
+jintcreateJarArchivejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID=NULL;
 
 
-    constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
-    if (constructObject == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+}
 
-    localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
-    if (localInstance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+ScilabJarCreator::ScilabJarCreator(JavaVM * jvm_, jobject JObj) {
+        jvm=jvm_;
 
-    this->instance = curEnv->NewGlobalRef(localInstance) ;
-    if (this->instance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-    /* localInstance not needed anymore */
-    curEnv->DeleteLocalRef(localInstance);
+        JNIEnv * curEnv = getCurrentEnv();
 
-    /* Methods ID set to NULL */
-    jintcreateJarArchivejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID = NULL;
+jclass localClass = curEnv->GetObjectClass(JObj);
+        this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+        curEnv->DeleteLocalRef(localClass);
+
+        if (this->instanceClass == NULL) {
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+        }
+
+        this->instance = curEnv->NewGlobalRef(JObj) ;
+        if(this->instance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+        }
+        /* Methods ID set to NULL */
+        jintcreateJarArchivejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID=NULL;
 
 
 }
 
-ScilabJarCreator::ScilabJarCreator(JavaVM * jvm_, jobject JObj)
-{
-    jvm = jvm_;
+// Generic methods
 
-    JNIEnv * curEnv = getCurrentEnv();
+void ScilabJarCreator::synchronize() {
+if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
+throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJarCreator");
+}
+}
 
-    jclass localClass = curEnv->GetObjectClass(JObj);
-    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
-    curEnv->DeleteLocalRef(localClass);
+void ScilabJarCreator::endSynchronize() {
+if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
+throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJarCreator");
+}
+}
+// Method(s)
 
-    if (this->instanceClass == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+int ScilabJarCreator::createJarArchive (JavaVM * jvm_, char const* jarFilePath, char const* const* filePaths, int filePathsSize, char const* filesRootPath, char const* manifestFilePath, bool keepAbsolutePaths){
 
-    this->instance = curEnv->NewGlobalRef(JObj) ;
-    if (this->instance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-    /* Methods ID set to NULL */
-    jintcreateJarArchivejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID = NULL;
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+jmethodID jintcreateJarArchivejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "createJarArchive", "(Ljava/lang/String;[Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Z)I" ) ;
+if (jintcreateJarArchivejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "createJarArchive");
+}
 
+jstring jarFilePath_ = curEnv->NewStringUTF( jarFilePath );
+if (jarFilePath != NULL && jarFilePath_ == NULL)
+{
+throw GiwsException::JniBadAllocException(curEnv);
 }
 
-// Generic methods
+jclass stringArrayClass = curEnv->FindClass("java/lang/String");
 
-void ScilabJarCreator::synchronize()
+// create java array of strings.
+jobjectArray filePaths_ = curEnv->NewObjectArray( filePathsSize, stringArrayClass, NULL);
+if (filePaths_ == NULL)
 {
-    if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK)
-    {
-        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJarCreator");
-    }
+throw GiwsException::JniBadAllocException(curEnv);
 }
 
-void ScilabJarCreator::endSynchronize()
+// convert each char * to java strings and fill the java array.
+for ( int i = 0; i < filePathsSize; i++)
 {
-    if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK)
-    {
-        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJarCreator");
-    }
+jstring TempString = curEnv->NewStringUTF( filePaths[i] );
+if (TempString == NULL)
+{
+throw GiwsException::JniBadAllocException(curEnv);
 }
-// Method(s)
 
-int ScilabJarCreator::createJarArchive (JavaVM * jvm_, char const* jarFilePath, char const* const* filePaths, int filePathsSize, char const* filesRootPath, char const* manifestFilePath, bool keepAbsolutePaths)
+curEnv->SetObjectArrayElement( filePaths_, i, TempString);
+
+// avoid keeping reference on too many strings
+curEnv->DeleteLocalRef(TempString);
+}
+jstring filesRootPath_ = curEnv->NewStringUTF( filesRootPath );
+if (filesRootPath != NULL && filesRootPath_ == NULL)
 {
+throw GiwsException::JniBadAllocException(curEnv);
+}
+
+
+jstring manifestFilePath_ = curEnv->NewStringUTF( manifestFilePath );
+if (manifestFilePath != NULL && manifestFilePath_ == NULL)
+{
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-
-    jmethodID jintcreateJarArchivejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "createJarArchive", "(Ljava/lang/String;[Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Z)I" ) ;
-    if (jintcreateJarArchivejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "createJarArchive");
-    }
-
-    jstring jarFilePath_ = curEnv->NewStringUTF( jarFilePath );
-    if (jarFilePath != NULL && jarFilePath_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
-
-    jclass stringArrayClass = curEnv->FindClass("java/lang/String");
-
-    // create java array of strings.
-    jobjectArray filePaths_ = curEnv->NewObjectArray( filePathsSize, stringArrayClass, NULL);
-    if (filePaths_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
-
-    // convert each char * to java strings and fill the java array.
-    for ( int i = 0; i < filePathsSize; i++)
-    {
-        jstring TempString = curEnv->NewStringUTF( filePaths[i] );
-        if (TempString == NULL)
-        {
-            throw GiwsException::JniBadAllocException(curEnv);
-        }
 
-        curEnv->SetObjectArrayElement( filePaths_, i, TempString);
-
-        // avoid keeping reference on to many strings
-        curEnv->DeleteLocalRef(TempString);
-    }
-    jstring filesRootPath_ = curEnv->NewStringUTF( filesRootPath );
-    if (filesRootPath != NULL && filesRootPath_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
-
-
-    jstring manifestFilePath_ = curEnv->NewStringUTF( manifestFilePath );
-    if (manifestFilePath != NULL && manifestFilePath_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
-
-
-    jboolean keepAbsolutePaths_ = (static_cast<bool>(keepAbsolutePaths) ? JNI_TRUE : JNI_FALSE);
-
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateJarArchivejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID , jarFilePath_, filePaths_, filesRootPath_, manifestFilePath_, keepAbsolutePaths_));
-    curEnv->DeleteLocalRef(stringArrayClass);
-    curEnv->DeleteLocalRef(jarFilePath_);
-    curEnv->DeleteLocalRef(filePaths_);
-    curEnv->DeleteLocalRef(filesRootPath_);
-    curEnv->DeleteLocalRef(manifestFilePath_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+jboolean keepAbsolutePaths_ = (static_cast<bool>(keepAbsolutePaths) ? JNI_TRUE : JNI_FALSE);
+
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcreateJarArchivejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID ,jarFilePath_, filePaths_, filesRootPath_, manifestFilePath_, keepAbsolutePaths_));
+                        curEnv->DeleteLocalRef(stringArrayClass);
+curEnv->DeleteLocalRef(jarFilePath_);
+curEnv->DeleteLocalRef(filePaths_);
+curEnv->DeleteLocalRef(filesRootPath_);
+curEnv->DeleteLocalRef(manifestFilePath_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
 }
 
index 013348b..a29b893 100644 (file)
@@ -1,5 +1,5 @@
-/* Generated by GIWS (version 2.0.1) with command:
-giws -e -f ScilabObjects.giws.xml
+/* Generated by GIWS (version 2.0.2) with command:
+giws -e -f ScilabObjects.giws.xml 
 */
 /*
 
@@ -46,11 +46,11 @@ knowledge of the CeCILL-B license and that you accept its terms.
 
 #include "GiwsException.hxx"
 
-#if defined(_MSC_VER) /* Defined anyway with Visual */
-#include <Windows.h>
-#else
-typedef signed char byte;
-#endif
+        #if defined(_MSC_VER) /* Defined anyway with Visual */
+            #include <Windows.h>
+        #else
+            typedef signed char byte;
+        #endif
 
 
 #ifndef GIWSEXPORT
@@ -69,89 +69,87 @@ typedef signed char byte;
 # endif
 #endif
 
-namespace org_scilab_modules_external_objects_java
-{
-class GIWSEXPORT ScilabJarCreator
-{
+namespace org_scilab_modules_external_objects_java {
+class GIWSEXPORT ScilabJarCreator {
 
 private:
-    JavaVM * jvm;
+JavaVM * jvm;
 
 protected:
-    jmethodID jintcreateJarArchivejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID; // cache method id
-    jclass stringArrayClass;
-
+jmethodID jintcreateJarArchivejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID; // cache method id
+jclass stringArrayClass;
 
 
-    jobject instance;
-    jclass instanceClass; // cache class
 
+jobject instance;
+jclass instanceClass; // cache class
 
-    // Caching (if any)
+                       
+// Caching (if any)
 
 
-    /**
-    * Get the environment matching to the current thread.
-    */
-    virtual JNIEnv * getCurrentEnv();
+/**
+* Get the environment matching to the current thread.
+*/
+virtual JNIEnv * getCurrentEnv();
 
 public:
-    // Constructor
-    /**
-    * Create a wrapping of the object from a JNIEnv.
-    * It will call the default constructor
-    * @param JEnv_ the Java Env
-    */
-    ScilabJarCreator(JavaVM * jvm_);
-
-    /**
-    * Create a wrapping of an already existing object from a JNIEnv.
-    * The object must have already been instantiated
-    * @param JEnv_ the Java Env
-    * @param JObj the object
-    */
-    ScilabJarCreator(JavaVM * jvm_, jobject JObj);
-
-
-    /**
-    * This is a fake constructor to avoid the constructor
-    * chaining when dealing with extended giws classes
-    */
-#ifdef FAKEGIWSDATATYPE
-    ScilabJarCreator(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
-#endif
-
-    // Destructor
-    ~ScilabJarCreator();
-
-    // Generic method
-    // Synchronization methods
-    /**
-    * Enter monitor associated with the object.
-    * Equivalent of creating a "synchronized(obj)" scope in Java.
-    */
-    void synchronize();
+// Constructor
+/**
+* Create a wrapping of the object from a JNIEnv.
+* It will call the default constructor
+* @param JEnv_ the Java Env
+*/
+ScilabJarCreator(JavaVM * jvm_);
 
-    /**
-    * Exit monitor associated with the object.
-    * Equivalent of ending a "synchronized(obj)" scope.
-    */
-    void endSynchronize();
+/**
+* Create a wrapping of an already existing object from a JNIEnv.
+* The object must have already been instantiated
+* @param JEnv_ the Java Env
+* @param JObj the object
+*/
+ScilabJarCreator(JavaVM * jvm_, jobject JObj);
 
-    // Methods
-    static int createJarArchive(JavaVM * jvm_, char const* jarFilePath, char const* const* filePaths, int filePathsSize, char const* filesRootPath, char const* manifestFilePath, bool keepAbsolutePaths);
 
+/** 
+* This is a fake constructor to avoid the constructor
+* chaining when dealing with extended giws classes 
+*/
+#ifdef FAKEGIWSDATATYPE
+ScilabJarCreator(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
+#endif
 
-    /**
-    * Get class name to use for static methods
-    * @return class name to use for static methods
-    */
+// Destructor
+~ScilabJarCreator();
 
-    static const std::string className()
-    {
-        return "org/scilab/modules/external_objects_java/ScilabJarCreator";
-    }
+// Generic method
+// Synchronization methods
+/**
+* Enter monitor associated with the object.
+* Equivalent of creating a "synchronized(obj)" scope in Java.
+*/
+void synchronize();
 
+/**
+* Exit monitor associated with the object.
+* Equivalent of ending a "synchronized(obj)" scope.
+*/
+void endSynchronize();
+
+// Methods
+static int createJarArchive(JavaVM * jvm_, char const* jarFilePath, char const* const* filePaths, int filePathsSize, char const* filesRootPath, char const* manifestFilePath, bool keepAbsolutePaths);
+
+
+                        /**
+                        * Get class name to use for static methods
+                        * @return class name to use for static methods
+                        */
+                        
+                static const std::string className()
+                {
+                return "org/scilab/modules/external_objects_java/ScilabJarCreator";
+                }
+                
 };
 
 
index e229940..c6ac74e 100644 (file)
@@ -1,6 +1,6 @@
 #include "ScilabJavaCompiler.hxx"
 /* Generated by GIWS (version 2.0.2) with command:
-giws -e -f ScilabObjects.giws.xml
+giws -e -f ScilabObjects.giws.xml 
 */
 /*
 
@@ -36,190 +36,168 @@ The fact that you are presently reading this means that you have had
 knowledge of the CeCILL-B license and that you accept its terms.
 */
 
-namespace org_scilab_modules_external_objects_java
-{
-
-// Static declarations (if any)
+namespace org_scilab_modules_external_objects_java {
 
+                // Static declarations (if any)
+                
 // Returns the current env
 
-JNIEnv * ScilabJavaCompiler::getCurrentEnv()
-{
-    JNIEnv * curEnv = NULL;
-    jint res = this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    if (res != JNI_OK)
-    {
-        throw GiwsException::JniException(getCurrentEnv());
-    }
-    return curEnv;
+JNIEnv * ScilabJavaCompiler::getCurrentEnv() {
+JNIEnv * curEnv = NULL;
+jint res=this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+if (res != JNI_OK) {
+throw GiwsException::JniException(getCurrentEnv());
+}
+return curEnv;
 }
 // Destructor
 
-ScilabJavaCompiler::~ScilabJavaCompiler()
-{
-    JNIEnv * curEnv = NULL;
-    this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    curEnv->DeleteGlobalRef(this->instance);
-    curEnv->DeleteGlobalRef(this->instanceClass);
-    curEnv->DeleteGlobalRef(this->stringArrayClass);
-}
+ScilabJavaCompiler::~ScilabJavaCompiler() {
+JNIEnv * curEnv = NULL;
+this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+curEnv->DeleteGlobalRef(this->instance);
+curEnv->DeleteGlobalRef(this->instanceClass);
+curEnv->DeleteGlobalRef(this->stringArrayClass);}
 // Constructors
-ScilabJavaCompiler::ScilabJavaCompiler(JavaVM * jvm_)
-{
-    jmethodID constructObject = NULL ;
-    jobject localInstance ;
-    jclass localClass ;
+ScilabJavaCompiler::ScilabJavaCompiler(JavaVM * jvm_) {
+jmethodID constructObject = NULL ;
+jobject localInstance ;
+jclass localClass ;
 
-    const std::string construct = "<init>";
-    const std::string param = "()V";
-    jvm = jvm_;
+const std::string construct="<init>";
+const std::string param="()V";
+jvm=jvm_;
 
-    JNIEnv * curEnv = getCurrentEnv();
+JNIEnv * curEnv = getCurrentEnv();
 
-    localClass = curEnv->FindClass( this->className().c_str() ) ;
-    if (localClass == NULL)
-    {
-        throw GiwsException::JniClassNotFoundException(curEnv, this->className());
-    }
-
-    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+localClass = curEnv->FindClass( this->className().c_str() ) ;
+if (localClass == NULL) {
+  throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+}
 
-    /* localClass is not needed anymore */
-    curEnv->DeleteLocalRef(localClass);
+this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
 
-    if (this->instanceClass == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+/* localClass is not needed anymore */
+curEnv->DeleteLocalRef(localClass);
 
+if (this->instanceClass == NULL) {
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
-    if (constructObject == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
 
-    localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
-    if (localInstance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
+if(constructObject == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    this->instance = curEnv->NewGlobalRef(localInstance) ;
-    if (this->instance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-    /* localInstance not needed anymore */
-    curEnv->DeleteLocalRef(localInstance);
+localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
+if(localInstance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+this->instance = curEnv->NewGlobalRef(localInstance) ;
+if(this->instance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+/* localInstance not needed anymore */
+curEnv->DeleteLocalRef(localInstance);
 
-    /* Methods ID set to NULL */
-    jintcompileCodejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID = NULL;
+                /* Methods ID set to NULL */
+jintcompileCodejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
 
 
 }
 
-ScilabJavaCompiler::ScilabJavaCompiler(JavaVM * jvm_, jobject JObj)
-{
-    jvm = jvm_;
+ScilabJavaCompiler::ScilabJavaCompiler(JavaVM * jvm_, jobject JObj) {
+        jvm=jvm_;
 
-    JNIEnv * curEnv = getCurrentEnv();
+        JNIEnv * curEnv = getCurrentEnv();
 
-    jclass localClass = curEnv->GetObjectClass(JObj);
-    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
-    curEnv->DeleteLocalRef(localClass);
+jclass localClass = curEnv->GetObjectClass(JObj);
+        this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+        curEnv->DeleteLocalRef(localClass);
 
-    if (this->instanceClass == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+        if (this->instanceClass == NULL) {
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+        }
 
-    this->instance = curEnv->NewGlobalRef(JObj) ;
-    if (this->instance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-    /* Methods ID set to NULL */
-    jintcompileCodejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID = NULL;
+        this->instance = curEnv->NewGlobalRef(JObj) ;
+        if(this->instance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+        }
+        /* Methods ID set to NULL */
+        jintcompileCodejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
 
 
 }
 
 // Generic methods
 
-void ScilabJavaCompiler::synchronize()
+void ScilabJavaCompiler::synchronize() {
+if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
+throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaCompiler");
+}
+}
+
+void ScilabJavaCompiler::endSynchronize() {
+if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
+throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaCompiler");
+}
+}
+// Method(s)
+
+int ScilabJavaCompiler::compileCode (JavaVM * jvm_, char const* classname, char const* const* code, int codeSize){
+
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+
+jmethodID jintcompileCodejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "compileCode", "(Ljava/lang/String;[Ljava/lang/String;)I" ) ;
+if (jintcompileCodejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "compileCode");
+}
+
+jstring classname_ = curEnv->NewStringUTF( classname );
+if (classname != NULL && classname_ == NULL)
 {
-    if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK)
-    {
-        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaCompiler");
-    }
+throw GiwsException::JniBadAllocException(curEnv);
 }
 
-void ScilabJavaCompiler::endSynchronize()
+jclass stringArrayClass = curEnv->FindClass("java/lang/String");
+
+// create java array of strings.
+jobjectArray code_ = curEnv->NewObjectArray( codeSize, stringArrayClass, NULL);
+if (code_ == NULL)
 {
-    if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK)
-    {
-        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaCompiler");
-    }
+throw GiwsException::JniBadAllocException(curEnv);
 }
-// Method(s)
 
-int ScilabJavaCompiler::compileCode (JavaVM * jvm_, char const* classname, char const* const* code, int codeSize)
+// convert each char * to java strings and fill the java array.
+for ( int i = 0; i < codeSize; i++)
+{
+jstring TempString = curEnv->NewStringUTF( code[i] );
+if (TempString == NULL)
 {
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID jintcompileCodejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "compileCode", "(Ljava/lang/String;[Ljava/lang/String;)I" ) ;
-    if (jintcompileCodejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "compileCode");
-    }
-
-    jstring classname_ = curEnv->NewStringUTF( classname );
-    if (classname != NULL && classname_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
-
-    jclass stringArrayClass = curEnv->FindClass("java/lang/String");
-
-    // create java array of strings.
-    jobjectArray code_ = curEnv->NewObjectArray( codeSize, stringArrayClass, NULL);
-    if (code_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
-
-    // convert each char * to java strings and fill the java array.
-    for ( int i = 0; i < codeSize; i++)
-    {
-        jstring TempString = curEnv->NewStringUTF( code[i] );
-        if (TempString == NULL)
-        {
-            throw GiwsException::JniBadAllocException(curEnv);
-        }
+curEnv->SetObjectArrayElement( code_, i, TempString);
 
-        curEnv->SetObjectArrayElement( code_, i, TempString);
-
-        // avoid keeping reference on too many strings
-        curEnv->DeleteLocalRef(TempString);
-    }
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcompileCodejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID , classname_, code_));
-    curEnv->DeleteLocalRef(stringArrayClass);
-    curEnv->DeleteLocalRef(classname_);
-    curEnv->DeleteLocalRef(code_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+// avoid keeping reference on too many strings
+curEnv->DeleteLocalRef(TempString);
+}
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcompileCodejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID ,classname_, code_));
+                        curEnv->DeleteLocalRef(stringArrayClass);
+curEnv->DeleteLocalRef(classname_);
+curEnv->DeleteLocalRef(code_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
 }
 
index be4072e..4467fdb 100644 (file)
@@ -1,6 +1,6 @@
 #include "ScilabJavaObject.hxx"
 /* Generated by GIWS (version 2.0.2) with command:
-giws -e -f ScilabObjects.giws.xml
+giws -e -f ScilabObjects.giws.xml 
 */
 /*
 
@@ -36,2286 +36,2013 @@ The fact that you are presently reading this means that you have had
 knowledge of the CeCILL-B license and that you accept its terms.
 */
 
-namespace org_scilab_modules_external_objects_java
-{
-
-// Static declarations (if any)
+namespace org_scilab_modules_external_objects_java {
 
+                // Static declarations (if any)
+                
 // Returns the current env
 
-JNIEnv * ScilabJavaObject::getCurrentEnv()
-{
-    JNIEnv * curEnv = NULL;
-    jint res = this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    if (res != JNI_OK)
-    {
-        throw GiwsException::JniException(getCurrentEnv());
-    }
-    return curEnv;
+JNIEnv * ScilabJavaObject::getCurrentEnv() {
+JNIEnv * curEnv = NULL;
+jint res=this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+if (res != JNI_OK) {
+throw GiwsException::JniException(getCurrentEnv());
+}
+return curEnv;
 }
 // Destructor
 
-ScilabJavaObject::~ScilabJavaObject()
-{
-    JNIEnv * curEnv = NULL;
-    this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    curEnv->DeleteGlobalRef(this->instance);
-    curEnv->DeleteGlobalRef(this->instanceClass);
-    curEnv->DeleteGlobalRef(this->stringArrayClass);
-}
+ScilabJavaObject::~ScilabJavaObject() {
+JNIEnv * curEnv = NULL;
+this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+curEnv->DeleteGlobalRef(this->instance);
+curEnv->DeleteGlobalRef(this->instanceClass);
+curEnv->DeleteGlobalRef(this->stringArrayClass);}
 // Constructors
-ScilabJavaObject::ScilabJavaObject(JavaVM * jvm_)
-{
-    jmethodID constructObject = NULL ;
-    jobject localInstance ;
-    jclass localClass ;
-
-    const std::string construct = "<init>";
-    const std::string param = "()V";
-    jvm = jvm_;
-
-    JNIEnv * curEnv = getCurrentEnv();
-
-    localClass = curEnv->FindClass( this->className().c_str() ) ;
-    if (localClass == NULL)
-    {
-        throw GiwsException::JniClassNotFoundException(curEnv, this->className());
-    }
-
-    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
-
-    /* localClass is not needed anymore */
-    curEnv->DeleteLocalRef(localClass);
-
-    if (this->instanceClass == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-
-
-    constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
-    if (constructObject == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-
-    localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
-    if (localInstance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-
-    this->instance = curEnv->NewGlobalRef(localInstance) ;
-    if (this->instance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-    /* localInstance not needed anymore */
-    curEnv->DeleteLocalRef(localInstance);
-
-    /* Methods ID set to NULL */
-    jintinvokejintintjstringjava_lang_StringjintArray_intintID = NULL;
-    jintextractjintintjintArray_intintID = NULL;
-    voidinsertjintintjintArray_intintjintintID = NULL;
-    jobjectArray_getInfosID = NULL;
-    voidinitScilabJavaObjectID = NULL;
-    voidgarbageCollectID = NULL;
-    jstringgetRepresentationjintintID = NULL;
-    jbooleanisValidJavaObjectjintintID = NULL;
-    voidenableTracejstringjava_lang_StringID = NULL;
-    voiddisableTraceID = NULL;
-    voidwriteLogjstringjava_lang_StringID = NULL;
-    voidsetFieldjintintjstringjava_lang_StringjintintID = NULL;
-    jintgetFieldjintintjstringjava_lang_StringID = NULL;
-    jintgetFieldTypejintintjstringjava_lang_StringID = NULL;
-    jintjavaCastjintintjstringjava_lang_StringID = NULL;
-    jintjavaCastjintintjintintID = NULL;
-    jstringgetClassNamejintintID = NULL;
-    jintgetArrayElementjintintjintArray_intintID = NULL;
-    voidsetArrayElementjintintjintArray_intintjintintID = NULL;
-    voidremoveScilabJavaObjectjintintID = NULL;
-    voidremoveScilabJavaObjectjintArray_intintID = NULL;
-    voidlimitDirectBufferjintintID = NULL;
-    jintisUnwrappablejintintID = NULL;
-    jintwrapjdoubledoubleID = NULL;
-    jintwrapjdoubleArray_doubledoubleID = NULL;
-    jintwrapjobjectArray__doubledoubleID = NULL;
-    jintwrapjintintID = NULL;
-    jintwrapjintArray_intintID = NULL;
-    jintwrapjobjectArray__intintID = NULL;
-    jintwrapjbytebyteID = NULL;
-    jintwrapjbyteArray_bytebyteID = NULL;
-    jintwrapjobjectArray__bytebyteID = NULL;
-    jintwrapjshortshortID = NULL;
-    jintwrapjshortArray_shortshortID = NULL;
-    jintwrapjobjectArray__shortshortID = NULL;
-    jintwrapjstringjava_lang_StringID = NULL;
-    jintwrapjobjectArray_java_lang_Stringjava_lang_StringID = NULL;
-    jintwrapjobjectArray__java_lang_Stringjava_lang_StringID = NULL;
-    jintwrapjbooleanbooleanID = NULL;
-    jintwrapjbooleanArray_booleanbooleanID = NULL;
-    jintwrapjobjectArray__booleanbooleanID = NULL;
-    jintwrapjcharcharID = NULL;
-    jintwrapjcharArray_charcharID = NULL;
-    jintwrapjobjectArray__charcharID = NULL;
-    jintwrapjfloatfloatID = NULL;
-    jintwrapjfloatArray_floatfloatID = NULL;
-    jintwrapjobjectArray__floatfloatID = NULL;
-    jintwrapjlonglongID = NULL;
-    jintwrapjlongArray_longlongID = NULL;
-    jintwrapjobjectArray__longlongID = NULL;
-    jobjectArray_getAccessibleFieldsjintintID = NULL;
-    jobjectArray_getAccessibleMethodsjintintID = NULL;
-    jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID = NULL;
-
-
-}
-
-ScilabJavaObject::ScilabJavaObject(JavaVM * jvm_, jobject JObj)
-{
-    jvm = jvm_;
-
-    JNIEnv * curEnv = getCurrentEnv();
-
-    jclass localClass = curEnv->GetObjectClass(JObj);
-    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
-    curEnv->DeleteLocalRef(localClass);
-
-    if (this->instanceClass == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-
-    this->instance = curEnv->NewGlobalRef(JObj) ;
-    if (this->instance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-    /* Methods ID set to NULL */
-    jintinvokejintintjstringjava_lang_StringjintArray_intintID = NULL;
-    jintextractjintintjintArray_intintID = NULL;
-    voidinsertjintintjintArray_intintjintintID = NULL;
-    jobjectArray_getInfosID = NULL;
-    voidinitScilabJavaObjectID = NULL;
-    voidgarbageCollectID = NULL;
-    jstringgetRepresentationjintintID = NULL;
-    jbooleanisValidJavaObjectjintintID = NULL;
-    voidenableTracejstringjava_lang_StringID = NULL;
-    voiddisableTraceID = NULL;
-    voidwriteLogjstringjava_lang_StringID = NULL;
-    voidsetFieldjintintjstringjava_lang_StringjintintID = NULL;
-    jintgetFieldjintintjstringjava_lang_StringID = NULL;
-    jintgetFieldTypejintintjstringjava_lang_StringID = NULL;
-    jintjavaCastjintintjstringjava_lang_StringID = NULL;
-    jintjavaCastjintintjintintID = NULL;
-    jstringgetClassNamejintintID = NULL;
-    jintgetArrayElementjintintjintArray_intintID = NULL;
-    voidsetArrayElementjintintjintArray_intintjintintID = NULL;
-    voidremoveScilabJavaObjectjintintID = NULL;
-    voidremoveScilabJavaObjectjintArray_intintID = NULL;
-    voidlimitDirectBufferjintintID = NULL;
-    jintisUnwrappablejintintID = NULL;
-    jintwrapjdoubledoubleID = NULL;
-    jintwrapjdoubleArray_doubledoubleID = NULL;
-    jintwrapjobjectArray__doubledoubleID = NULL;
-    jintwrapjintintID = NULL;
-    jintwrapjintArray_intintID = NULL;
-    jintwrapjobjectArray__intintID = NULL;
-    jintwrapjbytebyteID = NULL;
-    jintwrapjbyteArray_bytebyteID = NULL;
-    jintwrapjobjectArray__bytebyteID = NULL;
-    jintwrapjshortshortID = NULL;
-    jintwrapjshortArray_shortshortID = NULL;
-    jintwrapjobjectArray__shortshortID = NULL;
-    jintwrapjstringjava_lang_StringID = NULL;
-    jintwrapjobjectArray_java_lang_Stringjava_lang_StringID = NULL;
-    jintwrapjobjectArray__java_lang_Stringjava_lang_StringID = NULL;
-    jintwrapjbooleanbooleanID = NULL;
-    jintwrapjbooleanArray_booleanbooleanID = NULL;
-    jintwrapjobjectArray__booleanbooleanID = NULL;
-    jintwrapjcharcharID = NULL;
-    jintwrapjcharArray_charcharID = NULL;
-    jintwrapjobjectArray__charcharID = NULL;
-    jintwrapjfloatfloatID = NULL;
-    jintwrapjfloatArray_floatfloatID = NULL;
-    jintwrapjobjectArray__floatfloatID = NULL;
-    jintwrapjlonglongID = NULL;
-    jintwrapjlongArray_longlongID = NULL;
-    jintwrapjobjectArray__longlongID = NULL;
-    jobjectArray_getAccessibleFieldsjintintID = NULL;
-    jobjectArray_getAccessibleMethodsjintintID = NULL;
-    jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID = NULL;
+ScilabJavaObject::ScilabJavaObject(JavaVM * jvm_) {
+jmethodID constructObject = NULL ;
+jobject localInstance ;
+jclass localClass ;
+
+const std::string construct="<init>";
+const std::string param="()V";
+jvm=jvm_;
+
+JNIEnv * curEnv = getCurrentEnv();
+
+localClass = curEnv->FindClass( this->className().c_str() ) ;
+if (localClass == NULL) {
+  throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+}
+
+this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+
+/* localClass is not needed anymore */
+curEnv->DeleteLocalRef(localClass);
+
+if (this->instanceClass == NULL) {
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+
+
+constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
+if(constructObject == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+
+localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
+if(localInstance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+this->instance = curEnv->NewGlobalRef(localInstance) ;
+if(this->instance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+/* localInstance not needed anymore */
+curEnv->DeleteLocalRef(localInstance);
+
+                /* Methods ID set to NULL */
+jintinvokejintintjstringjava_lang_StringjintArray_intintID=NULL;
+jintextractjintintjintArray_intintID=NULL;
+voidinsertjintintjintArray_intintjintintID=NULL;
+jobjectArray_getInfosID=NULL;
+voidinitScilabJavaObjectID=NULL;
+voidgarbageCollectID=NULL;
+jstringgetRepresentationjintintID=NULL;
+jbooleanisValidJavaObjectjintintID=NULL;
+voidenableTracejstringjava_lang_StringID=NULL;
+voiddisableTraceID=NULL;
+voidwriteLogjstringjava_lang_StringID=NULL;
+voidsetFieldjintintjstringjava_lang_StringjintintID=NULL;
+jintgetFieldjintintjstringjava_lang_StringID=NULL;
+jintgetFieldTypejintintjstringjava_lang_StringID=NULL;
+jintjavaCastjintintjstringjava_lang_StringID=NULL;
+jintjavaCastjintintjintintID=NULL;
+jstringgetClassNamejintintID=NULL;
+jintgetArrayElementjintintjintArray_intintID=NULL;
+voidsetArrayElementjintintjintArray_intintjintintID=NULL;
+voidremoveScilabJavaObjectjintintID=NULL;
+voidremoveScilabJavaObjectjintArray_intintID=NULL;
+voidlimitDirectBufferjintintID=NULL;
+jintisUnwrappablejintintID=NULL;
+jintwrapjdoubledoubleID=NULL;
+jintwrapjdoubleArray_doubledoubleID=NULL;
+jintwrapjobjectArray__doubledoubleID=NULL;
+jintwrapjintintID=NULL;
+jintwrapjintArray_intintID=NULL;
+jintwrapjobjectArray__intintID=NULL;
+jintwrapjbytebyteID=NULL;
+jintwrapjbyteArray_bytebyteID=NULL;
+jintwrapjobjectArray__bytebyteID=NULL;
+jintwrapjshortshortID=NULL;
+jintwrapjshortArray_shortshortID=NULL;
+jintwrapjobjectArray__shortshortID=NULL;
+jintwrapjstringjava_lang_StringID=NULL;
+jintwrapjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
+jintwrapjobjectArray__java_lang_Stringjava_lang_StringID=NULL;
+jintwrapjbooleanbooleanID=NULL;
+jintwrapjbooleanArray_booleanbooleanID=NULL;
+jintwrapjobjectArray__booleanbooleanID=NULL;
+jintwrapjcharcharID=NULL;
+jintwrapjcharArray_charcharID=NULL;
+jintwrapjobjectArray__charcharID=NULL;
+jintwrapjfloatfloatID=NULL;
+jintwrapjfloatArray_floatfloatID=NULL;
+jintwrapjobjectArray__floatfloatID=NULL;
+jintwrapjlonglongID=NULL;
+jintwrapjlongArray_longlongID=NULL;
+jintwrapjobjectArray__longlongID=NULL;
+jobjectArray_getAccessibleFieldsjintintID=NULL;
+jobjectArray_getAccessibleMethodsjintintID=NULL;
+jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
+
+
+}
+
+ScilabJavaObject::ScilabJavaObject(JavaVM * jvm_, jobject JObj) {
+        jvm=jvm_;
+
+        JNIEnv * curEnv = getCurrentEnv();
+
+jclass localClass = curEnv->GetObjectClass(JObj);
+        this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+        curEnv->DeleteLocalRef(localClass);
+
+        if (this->instanceClass == NULL) {
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+        }
+
+        this->instance = curEnv->NewGlobalRef(JObj) ;
+        if(this->instance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+        }
+        /* Methods ID set to NULL */
+        jintinvokejintintjstringjava_lang_StringjintArray_intintID=NULL;
+jintextractjintintjintArray_intintID=NULL;
+voidinsertjintintjintArray_intintjintintID=NULL;
+jobjectArray_getInfosID=NULL;
+voidinitScilabJavaObjectID=NULL;
+voidgarbageCollectID=NULL;
+jstringgetRepresentationjintintID=NULL;
+jbooleanisValidJavaObjectjintintID=NULL;
+voidenableTracejstringjava_lang_StringID=NULL;
+voiddisableTraceID=NULL;
+voidwriteLogjstringjava_lang_StringID=NULL;
+voidsetFieldjintintjstringjava_lang_StringjintintID=NULL;
+jintgetFieldjintintjstringjava_lang_StringID=NULL;
+jintgetFieldTypejintintjstringjava_lang_StringID=NULL;
+jintjavaCastjintintjstringjava_lang_StringID=NULL;
+jintjavaCastjintintjintintID=NULL;
+jstringgetClassNamejintintID=NULL;
+jintgetArrayElementjintintjintArray_intintID=NULL;
+voidsetArrayElementjintintjintArray_intintjintintID=NULL;
+voidremoveScilabJavaObjectjintintID=NULL;
+voidremoveScilabJavaObjectjintArray_intintID=NULL;
+voidlimitDirectBufferjintintID=NULL;
+jintisUnwrappablejintintID=NULL;
+jintwrapjdoubledoubleID=NULL;
+jintwrapjdoubleArray_doubledoubleID=NULL;
+jintwrapjobjectArray__doubledoubleID=NULL;
+jintwrapjintintID=NULL;
+jintwrapjintArray_intintID=NULL;
+jintwrapjobjectArray__intintID=NULL;
+jintwrapjbytebyteID=NULL;
+jintwrapjbyteArray_bytebyteID=NULL;
+jintwrapjobjectArray__bytebyteID=NULL;
+jintwrapjshortshortID=NULL;
+jintwrapjshortArray_shortshortID=NULL;
+jintwrapjobjectArray__shortshortID=NULL;
+jintwrapjstringjava_lang_StringID=NULL;
+jintwrapjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
+jintwrapjobjectArray__java_lang_Stringjava_lang_StringID=NULL;
+jintwrapjbooleanbooleanID=NULL;
+jintwrapjbooleanArray_booleanbooleanID=NULL;
+jintwrapjobjectArray__booleanbooleanID=NULL;
+jintwrapjcharcharID=NULL;
+jintwrapjcharArray_charcharID=NULL;
+jintwrapjobjectArray__charcharID=NULL;
+jintwrapjfloatfloatID=NULL;
+jintwrapjfloatArray_floatfloatID=NULL;
+jintwrapjobjectArray__floatfloatID=NULL;
+jintwrapjlonglongID=NULL;
+jintwrapjlongArray_longlongID=NULL;
+jintwrapjobjectArray__longlongID=NULL;
+jobjectArray_getAccessibleFieldsjintintID=NULL;
+jobjectArray_getAccessibleMethodsjintintID=NULL;
+jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
 
 
 }
 
 // Generic methods
 
-void ScilabJavaObject::synchronize()
-{
-    if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK)
-    {
-        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaObject");
-    }
+void ScilabJavaObject::synchronize() {
+if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
+throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaObject");
+}
 }
 
-void ScilabJavaObject::endSynchronize()
-{
-    if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK)
-    {
-        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaObject");
-    }
+void ScilabJavaObject::endSynchronize() {
+if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
+throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaObject");
+}
 }
 // Method(s)
 
-int ScilabJavaObject::invoke (JavaVM * jvm_, int id, char const* methodName, int const* args, int argsSize)
+int ScilabJavaObject::invoke (JavaVM * jvm_, int id, char const* methodName, int const* args, int argsSize){
+
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+
+jmethodID jintinvokejintintjstringjava_lang_StringjintArray_intintID = curEnv->GetStaticMethodID(cls, "invoke", "(ILjava/lang/String;[I)I" ) ;
+if (jintinvokejintintjstringjava_lang_StringjintArray_intintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "invoke");
+}
+
+jstring methodName_ = curEnv->NewStringUTF( methodName );
+if (methodName != NULL && methodName_ == NULL)
 {
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
 
-    jmethodID jintinvokejintintjstringjava_lang_StringjintArray_intintID = curEnv->GetStaticMethodID(cls, "invoke", "(ILjava/lang/String;[I)I" ) ;
-    if (jintinvokejintintjstringjava_lang_StringjintArray_intintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "invoke");
-    }
+jintArray args_ = curEnv->NewIntArray( argsSize ) ;
 
-    jstring methodName_ = curEnv->NewStringUTF( methodName );
-    if (methodName != NULL && methodName_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+if (args_ == NULL)
+{
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
+curEnv->SetIntArrayRegion( args_, 0, argsSize, (jint*)(args) ) ;
 
-    jintArray args_ = curEnv->NewIntArray( argsSize ) ;
 
-    if (args_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintinvokejintintjstringjava_lang_StringjintArray_intintID ,id, methodName_, args_));
+                        curEnv->DeleteLocalRef(methodName_);
+curEnv->DeleteLocalRef(args_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    curEnv->SetIntArrayRegion( args_, 0, argsSize, (jint*)(args) ) ;
+}
 
+int ScilabJavaObject::extract (JavaVM * jvm_, int id, int const* args, int argsSize){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintinvokejintintjstringjava_lang_StringjintArray_intintID , id, methodName_, args_));
-    curEnv->DeleteLocalRef(methodName_);
-    curEnv->DeleteLocalRef(args_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+jmethodID jintextractjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "extract", "(I[I)I" ) ;
+if (jintextractjintintjintArray_intintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "extract");
 }
 
-int ScilabJavaObject::extract (JavaVM * jvm_, int id, int const* args, int argsSize)
-{
+jintArray args_ = curEnv->NewIntArray( argsSize ) ;
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+if (args_ == NULL)
+{
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    jmethodID jintextractjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "extract", "(I[I)I" ) ;
-    if (jintextractjintintjintArray_intintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "extract");
-    }
+curEnv->SetIntArrayRegion( args_, 0, argsSize, (jint*)(args) ) ;
 
-    jintArray args_ = curEnv->NewIntArray( argsSize ) ;
 
-    if (args_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintextractjintintjintArray_intintID ,id, args_));
+                        curEnv->DeleteLocalRef(args_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    curEnv->SetIntArrayRegion( args_, 0, argsSize, (jint*)(args) ) ;
+}
 
+void ScilabJavaObject::insert (JavaVM * jvm_, int id, int const* keys, int keysSize, int value){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintextractjintintjintArray_intintID , id, args_));
-    curEnv->DeleteLocalRef(args_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+jmethodID voidinsertjintintjintArray_intintjintintID = curEnv->GetStaticMethodID(cls, "insert", "(I[II)V" ) ;
+if (voidinsertjintintjintArray_intintjintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "insert");
 }
 
-void ScilabJavaObject::insert (JavaVM * jvm_, int id, int const* keys, int keysSize, int value)
+jintArray keys_ = curEnv->NewIntArray( keysSize ) ;
+
+if (keys_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+curEnv->SetIntArrayRegion( keys_, 0, keysSize, (jint*)(keys) ) ;
 
-    jmethodID voidinsertjintintjintArray_intintjintintID = curEnv->GetStaticMethodID(cls, "insert", "(I[II)V" ) ;
-    if (voidinsertjintintjintArray_intintjintintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "insert");
-    }
 
-    jintArray keys_ = curEnv->NewIntArray( keysSize ) ;
+                         curEnv->CallStaticVoidMethod(cls, voidinsertjintintjintArray_intintjintintID ,id, keys_, value);
+                        curEnv->DeleteLocalRef(keys_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+}
 
-    if (keys_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+char** ScilabJavaObject::getInfos (JavaVM * jvm_, int *lenRow){
 
-    curEnv->SetIntArrayRegion( keys_, 0, keysSize, (jint*)(keys) ) ;
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+jmethodID jobjectArray_getInfosID = curEnv->GetStaticMethodID(cls, "getInfos", "()[Ljava/lang/String;" ) ;
+if (jobjectArray_getInfosID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "getInfos");
+}
 
-    curEnv->CallStaticVoidMethod(cls, voidinsertjintintjintArray_intintjintintID , id, keys_, value);
-    curEnv->DeleteLocalRef(keys_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+                        jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray_getInfosID ));
+                        if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}if (res != NULL) { 
+* lenRow = curEnv->GetArrayLength(res);
+
+char **arrayOfString;
+arrayOfString = new char *[*lenRow];
+for (jsize i = 0; i < *lenRow; i++){
+jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
+const char *tempString = curEnv->GetStringUTFChars(resString, 0);
+arrayOfString[i] = new char[strlen(tempString) + 1];
+
+strcpy(arrayOfString[i], tempString);
+curEnv->ReleaseStringUTFChars(resString, tempString);
+curEnv->DeleteLocalRef(resString);
+}
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+delete[] arrayOfString;
+                                throw GiwsException::JniCallMethodException(curEnv);
+}
+curEnv->DeleteLocalRef(res);
+return arrayOfString;
+ } else { 
+curEnv->DeleteLocalRef(res);
+return NULL;
+}
 }
 
-char** ScilabJavaObject::getInfos (JavaVM * jvm_, int *lenRow)
-{
+void ScilabJavaObject::initScilabJavaObject (JavaVM * jvm_){
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID jobjectArray_getInfosID = curEnv->GetStaticMethodID(cls, "getInfos", "()[Ljava/lang/String;" ) ;
-    if (jobjectArray_getInfosID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "getInfos");
-    }
-
-    jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray_getInfosID ));
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    if (res != NULL)
-    {
-        * lenRow = curEnv->GetArrayLength(res);
-
-        char **arrayOfString;
-        arrayOfString = new char *[*lenRow];
-        for (jsize i = 0; i < *lenRow; i++)
-        {
-            jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
-            const char *tempString = curEnv->GetStringUTFChars(resString, 0);
-            arrayOfString[i] = new char[strlen(tempString) + 1];
-
-            strcpy(arrayOfString[i], tempString);
-            curEnv->ReleaseStringUTFChars(resString, tempString);
-            curEnv->DeleteLocalRef(resString);
-        }
-        curEnv->DeleteLocalRef(cls);
-        if (curEnv->ExceptionCheck())
-        {
-            delete[] arrayOfString;
-            throw GiwsException::JniCallMethodException(curEnv);
-        }
-        curEnv->DeleteLocalRef(res);
-        return arrayOfString;
-    }
-    else
-    {
-        curEnv->DeleteLocalRef(res);
-        return NULL;
-    }
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-void ScilabJavaObject::initScilabJavaObject (JavaVM * jvm_)
-{
+jmethodID voidinitScilabJavaObjectID = curEnv->GetStaticMethodID(cls, "initScilabJavaObject", "()V" ) ;
+if (voidinitScilabJavaObjectID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "initScilabJavaObject");
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID voidinitScilabJavaObjectID = curEnv->GetStaticMethodID(cls, "initScilabJavaObject", "()V" ) ;
-    if (voidinitScilabJavaObjectID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "initScilabJavaObject");
-    }
-
-    curEnv->CallStaticVoidMethod(cls, voidinitScilabJavaObjectID );
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-}
-
-void ScilabJavaObject::garbageCollect (JavaVM * jvm_)
-{
+                         curEnv->CallStaticVoidMethod(cls, voidinitScilabJavaObjectID );
+                        curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID voidgarbageCollectID = curEnv->GetStaticMethodID(cls, "garbageCollect", "()V" ) ;
-    if (voidgarbageCollectID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "garbageCollect");
-    }
-
-    curEnv->CallStaticVoidMethod(cls, voidgarbageCollectID );
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-}
-
-char* ScilabJavaObject::getRepresentation (JavaVM * jvm_, int id)
-{
+void ScilabJavaObject::garbageCollect (JavaVM * jvm_){
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID jstringgetRepresentationjintintID = curEnv->GetStaticMethodID(cls, "getRepresentation", "(I)Ljava/lang/String;" ) ;
-    if (jstringgetRepresentationjintintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "getRepresentation");
-    }
-
-    jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringgetRepresentationjintintID , id));
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    if (res != NULL)
-    {
-
-        const char *tempString = curEnv->GetStringUTFChars(res, 0);
-        char * myStringBuffer = new char[strlen(tempString) + 1];
-        strcpy(myStringBuffer, tempString);
-        curEnv->ReleaseStringUTFChars(res, tempString);
-        curEnv->DeleteLocalRef(res);
-        curEnv->DeleteLocalRef(cls);
-        if (curEnv->ExceptionCheck())
-        {
-            delete[] myStringBuffer;
-            throw GiwsException::JniCallMethodException(curEnv);
-        }
-        return myStringBuffer;
-    }
-    else
-    {
-        curEnv->DeleteLocalRef(res);
-        return NULL;
-    }
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-bool ScilabJavaObject::isValidJavaObject (JavaVM * jvm_, int id)
-{
+jmethodID voidgarbageCollectID = curEnv->GetStaticMethodID(cls, "garbageCollect", "()V" ) ;
+if (voidgarbageCollectID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "garbageCollect");
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+                         curEnv->CallStaticVoidMethod(cls, voidgarbageCollectID );
+                        curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+}
 
-    jmethodID jbooleanisValidJavaObjectjintintID = curEnv->GetStaticMethodID(cls, "isValidJavaObject", "(I)Z" ) ;
-    if (jbooleanisValidJavaObjectjintintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "isValidJavaObject");
-    }
+char* ScilabJavaObject::getRepresentation (JavaVM * jvm_, int id){
 
-    jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanisValidJavaObjectjintintID , id));
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return (res == JNI_TRUE);
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+jmethodID jstringgetRepresentationjintintID = curEnv->GetStaticMethodID(cls, "getRepresentation", "(I)Ljava/lang/String;" ) ;
+if (jstringgetRepresentationjintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "getRepresentation");
 }
 
-void ScilabJavaObject::enableTrace (JavaVM * jvm_, char const* filename)
-{
+                        jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringgetRepresentationjintintID ,id));
+                        if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}if (res != NULL) { 
+
+const char *tempString = curEnv->GetStringUTFChars(res, 0);
+char * myStringBuffer = new char[strlen(tempString) + 1];
+strcpy(myStringBuffer, tempString);
+curEnv->ReleaseStringUTFChars(res, tempString);
+curEnv->DeleteLocalRef(res);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+delete[] myStringBuffer;
+                                throw GiwsException::JniCallMethodException(curEnv);
+}
+return myStringBuffer;
+ } else { 
+curEnv->DeleteLocalRef(res);
+return NULL;
+}
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID voidenableTracejstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "enableTrace", "(Ljava/lang/String;)V" ) ;
-    if (voidenableTracejstringjava_lang_StringID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "enableTrace");
-    }
-
-    jstring filename_ = curEnv->NewStringUTF( filename );
-    if (filename != NULL && filename_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
-
-
-    curEnv->CallStaticVoidMethod(cls, voidenableTracejstringjava_lang_StringID , filename_);
-    curEnv->DeleteLocalRef(filename_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-}
-
-void ScilabJavaObject::disableTrace (JavaVM * jvm_)
-{
+bool ScilabJavaObject::isValidJavaObject (JavaVM * jvm_, int id){
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID voiddisableTraceID = curEnv->GetStaticMethodID(cls, "disableTrace", "()V" ) ;
-    if (voiddisableTraceID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "disableTrace");
-    }
-
-    curEnv->CallStaticVoidMethod(cls, voiddisableTraceID );
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-}
-
-void ScilabJavaObject::writeLog (JavaVM * jvm_, char const* s)
-{
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID voidwriteLogjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "writeLog", "(Ljava/lang/String;)V" ) ;
-    if (voidwriteLogjstringjava_lang_StringID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "writeLog");
-    }
-
-    jstring s_ = curEnv->NewStringUTF( s );
-    if (s != NULL && s_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
-
-
-    curEnv->CallStaticVoidMethod(cls, voidwriteLogjstringjava_lang_StringID , s_);
-    curEnv->DeleteLocalRef(s_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-}
-
-void ScilabJavaObject::setField (JavaVM * jvm_, int id, char const* fieldName, int idarg)
-{
+jmethodID jbooleanisValidJavaObjectjintintID = curEnv->GetStaticMethodID(cls, "isValidJavaObject", "(I)Z" ) ;
+if (jbooleanisValidJavaObjectjintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "isValidJavaObject");
+}
+
+                        jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanisValidJavaObjectjintintID ,id));
+                        curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return (res == JNI_TRUE);
+
+}
+
+void ScilabJavaObject::enableTrace (JavaVM * jvm_, char const* filename){
+
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+
+jmethodID voidenableTracejstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "enableTrace", "(Ljava/lang/String;)V" ) ;
+if (voidenableTracejstringjava_lang_StringID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "enableTrace");
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID voidsetFieldjintintjstringjava_lang_StringjintintID = curEnv->GetStaticMethodID(cls, "setField", "(ILjava/lang/String;I)V" ) ;
-    if (voidsetFieldjintintjstringjava_lang_StringjintintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "setField");
-    }
-
-    jstring fieldName_ = curEnv->NewStringUTF( fieldName );
-    if (fieldName != NULL && fieldName_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
-
-
-    curEnv->CallStaticVoidMethod(cls, voidsetFieldjintintjstringjava_lang_StringjintintID , id, fieldName_, idarg);
-    curEnv->DeleteLocalRef(fieldName_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-}
-
-int ScilabJavaObject::getField (JavaVM * jvm_, int id, char const* fieldName)
+jstring filename_ = curEnv->NewStringUTF( filename );
+if (filename != NULL && filename_ == NULL)
 {
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
 
-    jmethodID jintgetFieldjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "getField", "(ILjava/lang/String;)I" ) ;
-    if (jintgetFieldjintintjstringjava_lang_StringID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "getField");
-    }
+                         curEnv->CallStaticVoidMethod(cls, voidenableTracejstringjava_lang_StringID ,filename_);
+                        curEnv->DeleteLocalRef(filename_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+}
 
-    jstring fieldName_ = curEnv->NewStringUTF( fieldName );
-    if (fieldName != NULL && fieldName_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+void ScilabJavaObject::disableTrace (JavaVM * jvm_){
 
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetFieldjintintjstringjava_lang_StringID , id, fieldName_));
-    curEnv->DeleteLocalRef(fieldName_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+jmethodID voiddisableTraceID = curEnv->GetStaticMethodID(cls, "disableTrace", "()V" ) ;
+if (voiddisableTraceID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "disableTrace");
+}
 
+                         curEnv->CallStaticVoidMethod(cls, voiddisableTraceID );
+                        curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 }
 
-int ScilabJavaObject::getFieldType (JavaVM * jvm_, int id, char const* fieldName)
+void ScilabJavaObject::writeLog (JavaVM * jvm_, char const* s){
+
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+
+jmethodID voidwriteLogjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "writeLog", "(Ljava/lang/String;)V" ) ;
+if (voidwriteLogjstringjava_lang_StringID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "writeLog");
+}
+
+jstring s_ = curEnv->NewStringUTF( s );
+if (s != NULL && s_ == NULL)
 {
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
 
-    jmethodID jintgetFieldTypejintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "getFieldType", "(ILjava/lang/String;)I" ) ;
-    if (jintgetFieldTypejintintjstringjava_lang_StringID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "getFieldType");
-    }
+                         curEnv->CallStaticVoidMethod(cls, voidwriteLogjstringjava_lang_StringID ,s_);
+                        curEnv->DeleteLocalRef(s_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+}
+
+void ScilabJavaObject::setField (JavaVM * jvm_, int id, char const* fieldName, int idarg){
+
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+
+jmethodID voidsetFieldjintintjstringjava_lang_StringjintintID = curEnv->GetStaticMethodID(cls, "setField", "(ILjava/lang/String;I)V" ) ;
+if (voidsetFieldjintintjstringjava_lang_StringjintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "setField");
+}
 
-    jstring fieldName_ = curEnv->NewStringUTF( fieldName );
-    if (fieldName != NULL && fieldName_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+jstring fieldName_ = curEnv->NewStringUTF( fieldName );
+if (fieldName != NULL && fieldName_ == NULL)
+{
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetFieldTypejintintjstringjava_lang_StringID , id, fieldName_));
-    curEnv->DeleteLocalRef(fieldName_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+                         curEnv->CallStaticVoidMethod(cls, voidsetFieldjintintjstringjava_lang_StringjintintID ,id, fieldName_, idarg);
+                        curEnv->DeleteLocalRef(fieldName_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+}
+
+int ScilabJavaObject::getField (JavaVM * jvm_, int id, char const* fieldName){
+
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+jmethodID jintgetFieldjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "getField", "(ILjava/lang/String;)I" ) ;
+if (jintgetFieldjintintjstringjava_lang_StringID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "getField");
 }
 
-int ScilabJavaObject::javaCast (JavaVM * jvm_, int id, char const* objName)
+jstring fieldName_ = curEnv->NewStringUTF( fieldName );
+if (fieldName != NULL && fieldName_ == NULL)
 {
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
 
-    jmethodID jintjavaCastjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "javaCast", "(ILjava/lang/String;)I" ) ;
-    if (jintjavaCastjintintjstringjava_lang_StringID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "javaCast");
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetFieldjintintjstringjava_lang_StringID ,id, fieldName_));
+                        curEnv->DeleteLocalRef(fieldName_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    jstring objName_ = curEnv->NewStringUTF( objName );
-    if (objName != NULL && objName_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+}
 
+int ScilabJavaObject::getFieldType (JavaVM * jvm_, int id, char const* fieldName){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintjavaCastjintintjstringjava_lang_StringID , id, objName_));
-    curEnv->DeleteLocalRef(objName_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+jmethodID jintgetFieldTypejintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "getFieldType", "(ILjava/lang/String;)I" ) ;
+if (jintgetFieldTypejintintjstringjava_lang_StringID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "getFieldType");
 }
 
-int ScilabJavaObject::javaCast (JavaVM * jvm_, int id, int classId)
+jstring fieldName_ = curEnv->NewStringUTF( fieldName );
+if (fieldName != NULL && fieldName_ == NULL)
 {
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
 
-    jmethodID jintjavaCastjintintjintintID = curEnv->GetStaticMethodID(cls, "javaCast", "(II)I" ) ;
-    if (jintjavaCastjintintjintintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "javaCast");
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetFieldTypejintintjstringjava_lang_StringID ,id, fieldName_));
+                        curEnv->DeleteLocalRef(fieldName_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintjavaCastjintintjintintID , id, classId));
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+}
 
+int ScilabJavaObject::javaCast (JavaVM * jvm_, int id, char const* objName){
+
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+
+jmethodID jintjavaCastjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "javaCast", "(ILjava/lang/String;)I" ) ;
+if (jintjavaCastjintintjstringjava_lang_StringID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "javaCast");
 }
 
-char* ScilabJavaObject::getClassName (JavaVM * jvm_, int id)
+jstring objName_ = curEnv->NewStringUTF( objName );
+if (objName != NULL && objName_ == NULL)
 {
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID jstringgetClassNamejintintID = curEnv->GetStaticMethodID(cls, "getClassName", "(I)Ljava/lang/String;" ) ;
-    if (jstringgetClassNamejintintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "getClassName");
-    }
-
-    jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringgetClassNamejintintID , id));
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    if (res != NULL)
-    {
-
-        const char *tempString = curEnv->GetStringUTFChars(res, 0);
-        char * myStringBuffer = new char[strlen(tempString) + 1];
-        strcpy(myStringBuffer, tempString);
-        curEnv->ReleaseStringUTFChars(res, tempString);
-        curEnv->DeleteLocalRef(res);
-        curEnv->DeleteLocalRef(cls);
-        if (curEnv->ExceptionCheck())
-        {
-            delete[] myStringBuffer;
-            throw GiwsException::JniCallMethodException(curEnv);
-        }
-        return myStringBuffer;
-    }
-    else
-    {
-        curEnv->DeleteLocalRef(res);
-        return NULL;
-    }
+
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintjavaCastjintintjstringjava_lang_StringID ,id, objName_));
+                        curEnv->DeleteLocalRef(objName_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
+return res;
 
-int ScilabJavaObject::getArrayElement (JavaVM * jvm_, int id, int const* index, int indexSize)
-{
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+int ScilabJavaObject::javaCast (JavaVM * jvm_, int id, int classId){
 
-    jmethodID jintgetArrayElementjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "getArrayElement", "(I[I)I" ) ;
-    if (jintgetArrayElementjintintjintArray_intintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "getArrayElement");
-    }
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
-    jintArray index_ = curEnv->NewIntArray( indexSize ) ;
+jmethodID jintjavaCastjintintjintintID = curEnv->GetStaticMethodID(cls, "javaCast", "(II)I" ) ;
+if (jintjavaCastjintintjintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "javaCast");
+}
 
-    if (index_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintjavaCastjintintjintintID ,id, classId));
+                        curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
+
+}
 
-    curEnv->SetIntArrayRegion( index_, 0, indexSize, (jint*)(index) ) ;
+char* ScilabJavaObject::getClassName (JavaVM * jvm_, int id){
+
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+
+jmethodID jstringgetClassNamejintintID = curEnv->GetStaticMethodID(cls, "getClassName", "(I)Ljava/lang/String;" ) ;
+if (jstringgetClassNamejintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "getClassName");
+}
+
+                        jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringgetClassNamejintintID ,id));
+                        if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}if (res != NULL) { 
+
+const char *tempString = curEnv->GetStringUTFChars(res, 0);
+char * myStringBuffer = new char[strlen(tempString) + 1];
+strcpy(myStringBuffer, tempString);
+curEnv->ReleaseStringUTFChars(res, tempString);
+curEnv->DeleteLocalRef(res);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+delete[] myStringBuffer;
+                                throw GiwsException::JniCallMethodException(curEnv);
+}
+return myStringBuffer;
+ } else { 
+curEnv->DeleteLocalRef(res);
+return NULL;
+}
+}
 
+int ScilabJavaObject::getArrayElement (JavaVM * jvm_, int id, int const* index, int indexSize){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetArrayElementjintintjintArray_intintID , id, index_));
-    curEnv->DeleteLocalRef(index_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+jmethodID jintgetArrayElementjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "getArrayElement", "(I[I)I" ) ;
+if (jintgetArrayElementjintintjintArray_intintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "getArrayElement");
 }
 
-void ScilabJavaObject::setArrayElement (JavaVM * jvm_, int id, int const* index, int indexSize, int idArg)
+jintArray index_ = curEnv->NewIntArray( indexSize ) ;
+
+if (index_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+curEnv->SetIntArrayRegion( index_, 0, indexSize, (jint*)(index) ) ;
 
-    jmethodID voidsetArrayElementjintintjintArray_intintjintintID = curEnv->GetStaticMethodID(cls, "setArrayElement", "(I[II)V" ) ;
-    if (voidsetArrayElementjintintjintArray_intintjintintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "setArrayElement");
-    }
 
-    jintArray index_ = curEnv->NewIntArray( indexSize ) ;
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetArrayElementjintintjintArray_intintID ,id, index_));
+                        curEnv->DeleteLocalRef(index_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    if (index_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+}
 
-    curEnv->SetIntArrayRegion( index_, 0, indexSize, (jint*)(index) ) ;
+void ScilabJavaObject::setArrayElement (JavaVM * jvm_, int id, int const* index, int indexSize, int idArg){
 
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
-    curEnv->CallStaticVoidMethod(cls, voidsetArrayElementjintintjintArray_intintjintintID , id, index_, idArg);
-    curEnv->DeleteLocalRef(index_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+jmethodID voidsetArrayElementjintintjintArray_intintjintintID = curEnv->GetStaticMethodID(cls, "setArrayElement", "(I[II)V" ) ;
+if (voidsetArrayElementjintintjintArray_intintjintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "setArrayElement");
 }
 
-void ScilabJavaObject::removeScilabJavaObject (JavaVM * jvm_, int id)
-{
+jintArray index_ = curEnv->NewIntArray( indexSize ) ;
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID voidremoveScilabJavaObjectjintintID = curEnv->GetStaticMethodID(cls, "removeScilabJavaObject", "(I)V" ) ;
-    if (voidremoveScilabJavaObjectjintintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "removeScilabJavaObject");
-    }
-
-    curEnv->CallStaticVoidMethod(cls, voidremoveScilabJavaObjectjintintID , id);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-}
-
-void ScilabJavaObject::removeScilabJavaObject (JavaVM * jvm_, int const* id, int idSize)
+if (index_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
+
+curEnv->SetIntArrayRegion( index_, 0, indexSize, (jint*)(index) ) ;
+
+
+                         curEnv->CallStaticVoidMethod(cls, voidsetArrayElementjintintjintArray_intintjintintID ,id, index_, idArg);
+                        curEnv->DeleteLocalRef(index_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+void ScilabJavaObject::removeScilabJavaObject (JavaVM * jvm_, int id){
 
-    jmethodID voidremoveScilabJavaObjectjintArray_intintID = curEnv->GetStaticMethodID(cls, "removeScilabJavaObject", "([I)V" ) ;
-    if (voidremoveScilabJavaObjectjintArray_intintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "removeScilabJavaObject");
-    }
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
-    jintArray id_ = curEnv->NewIntArray( idSize ) ;
+jmethodID voidremoveScilabJavaObjectjintintID = curEnv->GetStaticMethodID(cls, "removeScilabJavaObject", "(I)V" ) ;
+if (voidremoveScilabJavaObjectjintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "removeScilabJavaObject");
+}
 
-    if (id_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+                         curEnv->CallStaticVoidMethod(cls, voidremoveScilabJavaObjectjintintID ,id);
+                        curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+}
 
-    curEnv->SetIntArrayRegion( id_, 0, idSize, (jint*)(id) ) ;
+void ScilabJavaObject::removeScilabJavaObject (JavaVM * jvm_, int const* id, int idSize){
 
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
-    curEnv->CallStaticVoidMethod(cls, voidremoveScilabJavaObjectjintArray_intintID , id_);
-    curEnv->DeleteLocalRef(id_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+jmethodID voidremoveScilabJavaObjectjintArray_intintID = curEnv->GetStaticMethodID(cls, "removeScilabJavaObject", "([I)V" ) ;
+if (voidremoveScilabJavaObjectjintArray_intintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "removeScilabJavaObject");
 }
 
-void ScilabJavaObject::limitDirectBuffer (JavaVM * jvm_, int id)
-{
+jintArray id_ = curEnv->NewIntArray( idSize ) ;
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID voidlimitDirectBufferjintintID = curEnv->GetStaticMethodID(cls, "limitDirectBuffer", "(I)V" ) ;
-    if (voidlimitDirectBufferjintintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "limitDirectBuffer");
-    }
-
-    curEnv->CallStaticVoidMethod(cls, voidlimitDirectBufferjintintID , id);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-}
-
-int ScilabJavaObject::isUnwrappable (JavaVM * jvm_, int id)
+if (id_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+curEnv->SetIntArrayRegion( id_, 0, idSize, (jint*)(id) ) ;
 
-    jmethodID jintisUnwrappablejintintID = curEnv->GetStaticMethodID(cls, "isUnwrappable", "(I)I" ) ;
-    if (jintisUnwrappablejintintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "isUnwrappable");
-    }
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintisUnwrappablejintintID , id));
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+                         curEnv->CallStaticVoidMethod(cls, voidremoveScilabJavaObjectjintArray_intintID ,id_);
+                        curEnv->DeleteLocalRef(id_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+}
 
+void ScilabJavaObject::limitDirectBuffer (JavaVM * jvm_, int id){
+
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, double x)
-{
+jmethodID voidlimitDirectBufferjintintID = curEnv->GetStaticMethodID(cls, "limitDirectBuffer", "(I)V" ) ;
+if (voidlimitDirectBufferjintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "limitDirectBuffer");
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+                         curEnv->CallStaticVoidMethod(cls, voidlimitDirectBufferjintintID ,id);
+                        curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+}
 
-    jmethodID jintwrapjdoubledoubleID = curEnv->GetStaticMethodID(cls, "wrap", "(D)I" ) ;
-    if (jintwrapjdoubledoubleID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+int ScilabJavaObject::isUnwrappable (JavaVM * jvm_, int id){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjdoubledoubleID , x));
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+jmethodID jintisUnwrappablejintintID = curEnv->GetStaticMethodID(cls, "isUnwrappable", "(I)I" ) ;
+if (jintisUnwrappablejintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "isUnwrappable");
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, double const* x, int xSize)
-{
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintisUnwrappablejintintID ,id));
+                        curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+}
 
-    jmethodID jintwrapjdoubleArray_doubledoubleID = curEnv->GetStaticMethodID(cls, "wrap", "([D)I" ) ;
-    if (jintwrapjdoubleArray_doubledoubleID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+int ScilabJavaObject::wrap (JavaVM * jvm_, double x){
 
-    jdoubleArray x_ = curEnv->NewDoubleArray( xSize ) ;
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
-    if (x_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+jmethodID jintwrapjdoubledoubleID = curEnv->GetStaticMethodID(cls, "wrap", "(D)I" ) ;
+if (jintwrapjdoubledoubleID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+}
+
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjdoubledoubleID ,x));
+                        curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    curEnv->SetDoubleArrayRegion( x_, 0, xSize, (jdouble*)(x) ) ;
+}
 
+int ScilabJavaObject::wrap (JavaVM * jvm_, double const* x, int xSize){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjdoubleArray_doubledoubleID , x_));
-    curEnv->DeleteLocalRef(x_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+jmethodID jintwrapjdoubleArray_doubledoubleID = curEnv->GetStaticMethodID(cls, "wrap", "([D)I" ) ;
+if (jintwrapjdoubleArray_doubledoubleID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, double const* const* x, int xSize, int xSizeCol)
+jdoubleArray x_ = curEnv->NewDoubleArray( xSize ) ;
+
+if (x_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID jintwrapjobjectArray__doubledoubleID = curEnv->GetStaticMethodID(cls, "wrap", "([[D)I" ) ;
-    if (jintwrapjobjectArray__doubledoubleID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
-
-    jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[D"), NULL);
-
-    if (x_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
-
-    for (int i = 0; i < xSize; i++)
-    {
-
-        jdoubleArray xLocal = curEnv->NewDoubleArray( xSizeCol ) ;
-
-        if (xLocal == NULL)
-        {
-            // check that allocation succeed
-            curEnv->DeleteLocalRef(x_);
-            throw GiwsException::JniBadAllocException(curEnv);
-        }
+curEnv->SetDoubleArrayRegion( x_, 0, xSize, (jdouble*)(x) ) ;
 
-        curEnv->SetDoubleArrayRegion( xLocal, 0, xSizeCol, (jdouble*)(x[i]) ) ;
-        curEnv->SetObjectArrayElement(x_, i, xLocal);
-        curEnv->DeleteLocalRef(xLocal);
-    }
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__doubledoubleID , x_));
-    curEnv->DeleteLocalRef(x_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjdoubleArray_doubledoubleID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, int x)
-{
+int ScilabJavaObject::wrap (JavaVM * jvm_, double const* const* x, int xSize, int xSizeCol){
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
-    jmethodID jintwrapjintintID = curEnv->GetStaticMethodID(cls, "wrap", "(I)I" ) ;
-    if (jintwrapjintintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+jmethodID jintwrapjobjectArray__doubledoubleID = curEnv->GetStaticMethodID(cls, "wrap", "([[D)I" ) ;
+if (jintwrapjobjectArray__doubledoubleID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjintintID , x));
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+ jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[D"),NULL);
 
+if (x_ == NULL)
+{
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, int const* x, int xSize)
-{
+ for (int i=0; i<xSize; i++){
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+jdoubleArray xLocal = curEnv->NewDoubleArray( xSizeCol ) ;
 
-    jmethodID jintwrapjintArray_intintID = curEnv->GetStaticMethodID(cls, "wrap", "([I)I" ) ;
-    if (jintwrapjintArray_intintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+if (xLocal == NULL)
+{
+// check that allocation succeed
+curEnv->DeleteLocalRef(x_);
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    jintArray x_ = curEnv->NewIntArray( xSize ) ;
+curEnv->SetDoubleArrayRegion( xLocal, 0, xSizeCol, (jdouble*)(x[i]) ) ;
+curEnv->SetObjectArrayElement(x_, i, xLocal);
+curEnv->DeleteLocalRef(xLocal);
+}
 
-    if (x_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__doubledoubleID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    curEnv->SetIntArrayRegion( x_, 0, xSize, (jint*)(x) ) ;
+}
 
+int ScilabJavaObject::wrap (JavaVM * jvm_, int x){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjintArray_intintID , x_));
-    curEnv->DeleteLocalRef(x_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+jmethodID jintwrapjintintID = curEnv->GetStaticMethodID(cls, "wrap", "(I)I" ) ;
+if (jintwrapjintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, int const* const* x, int xSize, int xSizeCol)
-{
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjintintID ,x));
+                        curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID jintwrapjobjectArray__intintID = curEnv->GetStaticMethodID(cls, "wrap", "([[I)I" ) ;
-    if (jintwrapjobjectArray__intintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
-
-    jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[I"), NULL);
-
-    if (x_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
-
-    for (int i = 0; i < xSize; i++)
-    {
-
-        jintArray xLocal = curEnv->NewIntArray( xSizeCol ) ;
-
-        if (xLocal == NULL)
-        {
-            // check that allocation succeed
-            curEnv->DeleteLocalRef(x_);
-            throw GiwsException::JniBadAllocException(curEnv);
-        }
+}
 
-        curEnv->SetIntArrayRegion( xLocal, 0, xSizeCol, (jint*)(x[i]) ) ;
-        curEnv->SetObjectArrayElement(x_, i, xLocal);
-        curEnv->DeleteLocalRef(xLocal);
-    }
+int ScilabJavaObject::wrap (JavaVM * jvm_, int const* x, int xSize){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__intintID , x_));
-    curEnv->DeleteLocalRef(x_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+jmethodID jintwrapjintArray_intintID = curEnv->GetStaticMethodID(cls, "wrap", "([I)I" ) ;
+if (jintwrapjintArray_intintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, byte x)
+jintArray x_ = curEnv->NewIntArray( xSize ) ;
+
+if (x_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
+
+curEnv->SetIntArrayRegion( x_, 0, xSize, (jint*)(x) ) ;
+
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjintArray_intintID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    jmethodID jintwrapjbytebyteID = curEnv->GetStaticMethodID(cls, "wrap", "(B)I" ) ;
-    if (jintwrapjbytebyteID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbytebyteID , x));
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+int ScilabJavaObject::wrap (JavaVM * jvm_, int const* const* x, int xSize, int xSizeCol){
 
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, byte const* x, int xSize)
+jmethodID jintwrapjobjectArray__intintID = curEnv->GetStaticMethodID(cls, "wrap", "([[I)I" ) ;
+if (jintwrapjobjectArray__intintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+}
+
+ jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[I"),NULL);
+
+if (x_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+ for (int i=0; i<xSize; i++){
 
-    jmethodID jintwrapjbyteArray_bytebyteID = curEnv->GetStaticMethodID(cls, "wrap", "([B)I" ) ;
-    if (jintwrapjbyteArray_bytebyteID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+jintArray xLocal = curEnv->NewIntArray( xSizeCol ) ;
 
-    jbyteArray x_ = curEnv->NewByteArray( xSize ) ;
+if (xLocal == NULL)
+{
+// check that allocation succeed
+curEnv->DeleteLocalRef(x_);
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    if (x_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+curEnv->SetIntArrayRegion( xLocal, 0, xSizeCol, (jint*)(x[i]) ) ;
+curEnv->SetObjectArrayElement(x_, i, xLocal);
+curEnv->DeleteLocalRef(xLocal);
+}
 
-    curEnv->SetByteArrayRegion( x_, 0, xSize, (jbyte*)(x) ) ;
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__intintID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbyteArray_bytebyteID , x_));
-    curEnv->DeleteLocalRef(x_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+int ScilabJavaObject::wrap (JavaVM * jvm_, byte x){
 
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, byte const* const* x, int xSize, int xSizeCol)
-{
+jmethodID jintwrapjbytebyteID = curEnv->GetStaticMethodID(cls, "wrap", "(B)I" ) ;
+if (jintwrapjbytebyteID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID jintwrapjobjectArray__bytebyteID = curEnv->GetStaticMethodID(cls, "wrap", "([[B)I" ) ;
-    if (jintwrapjobjectArray__bytebyteID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
-
-    jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[B"), NULL);
-
-    if (x_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
-
-    for (int i = 0; i < xSize; i++)
-    {
-
-        jbyteArray xLocal = curEnv->NewByteArray( xSizeCol ) ;
-
-        if (xLocal == NULL)
-        {
-            // check that allocation succeed
-            curEnv->DeleteLocalRef(x_);
-            throw GiwsException::JniBadAllocException(curEnv);
-        }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbytebyteID ,x));
+                        curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-        curEnv->SetByteArrayRegion( xLocal, 0, xSizeCol, (jbyte*)(x[i]) ) ;
-        curEnv->SetObjectArrayElement(x_, i, xLocal);
-        curEnv->DeleteLocalRef(xLocal);
-    }
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__bytebyteID , x_));
-    curEnv->DeleteLocalRef(x_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+int ScilabJavaObject::wrap (JavaVM * jvm_, byte const* x, int xSize){
 
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, short x)
+jmethodID jintwrapjbyteArray_bytebyteID = curEnv->GetStaticMethodID(cls, "wrap", "([B)I" ) ;
+if (jintwrapjbyteArray_bytebyteID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+}
+
+jbyteArray x_ = curEnv->NewByteArray( xSize ) ;
+
+if (x_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
+
+curEnv->SetByteArrayRegion( x_, 0, xSize, (jbyte*)(x) ) ;
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
 
-    jmethodID jintwrapjshortshortID = curEnv->GetStaticMethodID(cls, "wrap", "(S)I" ) ;
-    if (jintwrapjshortshortID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbyteArray_bytebyteID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
+
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjshortshortID , x));
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+int ScilabJavaObject::wrap (JavaVM * jvm_, byte const* const* x, int xSize, int xSizeCol){
 
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, short const* x, int xSize)
+jmethodID jintwrapjobjectArray__bytebyteID = curEnv->GetStaticMethodID(cls, "wrap", "([[B)I" ) ;
+if (jintwrapjobjectArray__bytebyteID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+}
+
+ jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[B"),NULL);
+
+if (x_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+ for (int i=0; i<xSize; i++){
 
-    jmethodID jintwrapjshortArray_shortshortID = curEnv->GetStaticMethodID(cls, "wrap", "([S)I" ) ;
-    if (jintwrapjshortArray_shortshortID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+jbyteArray xLocal = curEnv->NewByteArray( xSizeCol ) ;
 
-    jshortArray x_ = curEnv->NewShortArray( xSize ) ;
+if (xLocal == NULL)
+{
+// check that allocation succeed
+curEnv->DeleteLocalRef(x_);
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    if (x_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+curEnv->SetByteArrayRegion( xLocal, 0, xSizeCol, (jbyte*)(x[i]) ) ;
+curEnv->SetObjectArrayElement(x_, i, xLocal);
+curEnv->DeleteLocalRef(xLocal);
+}
 
-    curEnv->SetShortArrayRegion( x_, 0, xSize, (jshort*)(x) ) ;
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__bytebyteID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjshortArray_shortshortID , x_));
-    curEnv->DeleteLocalRef(x_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+int ScilabJavaObject::wrap (JavaVM * jvm_, short x){
 
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, short const* const* x, int xSize, int xSizeCol)
-{
+jmethodID jintwrapjshortshortID = curEnv->GetStaticMethodID(cls, "wrap", "(S)I" ) ;
+if (jintwrapjshortshortID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID jintwrapjobjectArray__shortshortID = curEnv->GetStaticMethodID(cls, "wrap", "([[S)I" ) ;
-    if (jintwrapjobjectArray__shortshortID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
-
-    jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[S"), NULL);
-
-    if (x_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
-
-    for (int i = 0; i < xSize; i++)
-    {
-
-        jshortArray xLocal = curEnv->NewShortArray( xSizeCol ) ;
-
-        if (xLocal == NULL)
-        {
-            // check that allocation succeed
-            curEnv->DeleteLocalRef(x_);
-            throw GiwsException::JniBadAllocException(curEnv);
-        }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjshortshortID ,x));
+                        curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-        curEnv->SetShortArrayRegion( xLocal, 0, xSizeCol, (jshort*)(x[i]) ) ;
-        curEnv->SetObjectArrayElement(x_, i, xLocal);
-        curEnv->DeleteLocalRef(xLocal);
-    }
+}
+
+int ScilabJavaObject::wrap (JavaVM * jvm_, short const* x, int xSize){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__shortshortID , x_));
-    curEnv->DeleteLocalRef(x_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+jmethodID jintwrapjshortArray_shortshortID = curEnv->GetStaticMethodID(cls, "wrap", "([S)I" ) ;
+if (jintwrapjshortArray_shortshortID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, char const* x)
+jshortArray x_ = curEnv->NewShortArray( xSize ) ;
+
+if (x_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
+
+curEnv->SetShortArrayRegion( x_, 0, xSize, (jshort*)(x) ) ;
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
 
-    jmethodID jintwrapjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "wrap", "(Ljava/lang/String;)I" ) ;
-    if (jintwrapjstringjava_lang_StringID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjshortArray_shortshortID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    jstring x_ = curEnv->NewStringUTF( x );
-    if (x != NULL && x_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+}
 
+int ScilabJavaObject::wrap (JavaVM * jvm_, short const* const* x, int xSize, int xSizeCol){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjstringjava_lang_StringID , x_));
-    curEnv->DeleteLocalRef(x_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+jmethodID jintwrapjobjectArray__shortshortID = curEnv->GetStaticMethodID(cls, "wrap", "([[S)I" ) ;
+if (jintwrapjobjectArray__shortshortID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, char const* const* x, int xSize)
+ jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[S"),NULL);
+
+if (x_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID jintwrapjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "wrap", "([Ljava/lang/String;)I" ) ;
-    if (jintwrapjobjectArray_java_lang_Stringjava_lang_StringID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
-    jclass stringArrayClass = curEnv->FindClass("java/lang/String");
-
-    // create java array of strings.
-    jobjectArray x_ = curEnv->NewObjectArray( xSize, stringArrayClass, NULL);
-    if (x_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
-
-    // convert each char * to java strings and fill the java array.
-    for ( int i = 0; i < xSize; i++)
-    {
-        jstring TempString = curEnv->NewStringUTF( x[i] );
-        if (TempString == NULL)
-        {
-            throw GiwsException::JniBadAllocException(curEnv);
-        }
+ for (int i=0; i<xSize; i++){
 
-        curEnv->SetObjectArrayElement( x_, i, TempString);
+jshortArray xLocal = curEnv->NewShortArray( xSizeCol ) ;
 
-        // avoid keeping reference on too many strings
-        curEnv->DeleteLocalRef(TempString);
-    }
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray_java_lang_Stringjava_lang_StringID , x_));
-    curEnv->DeleteLocalRef(stringArrayClass);
-    curEnv->DeleteLocalRef(x_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+if (xLocal == NULL)
+{
+// check that allocation succeed
+curEnv->DeleteLocalRef(x_);
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
+curEnv->SetShortArrayRegion( xLocal, 0, xSizeCol, (jshort*)(x[i]) ) ;
+curEnv->SetObjectArrayElement(x_, i, xLocal);
+curEnv->DeleteLocalRef(xLocal);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, char const* const* const* x, int xSize, int xSizeCol)
-{
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__shortshortID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID jintwrapjobjectArray__java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "wrap", "([[Ljava/lang/String;)I" ) ;
-    if (jintwrapjobjectArray__java_lang_Stringjava_lang_StringID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
-    jclass stringArrayClass = curEnv->FindClass("java/lang/String");
-    // create java array of array of strings.
-    jobjectArray x_ = curEnv->NewObjectArray( xSize, curEnv->FindClass("[Ljava/lang/String;"), NULL);
-    if (x_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
-
-    for ( int i = 0; i < xSize; i++)
-    {
-        jobjectArray xLocal = curEnv->NewObjectArray( xSizeCol, stringArrayClass, NULL);
-        // convert each char * to java strings and fill the java array.
-        for ( int j = 0; j < xSizeCol; j++)
-        {
-            jstring TempString = curEnv->NewStringUTF( x[i][j] );
-
-            if (TempString == NULL)
-            {
-                throw GiwsException::JniBadAllocException(curEnv);
-            }
-
-            curEnv->SetObjectArrayElement( xLocal, j, TempString);
-
-            // avoid keeping reference on too many strings
-            curEnv->DeleteLocalRef(TempString);
-        }
-        curEnv->SetObjectArrayElement(x_, i, xLocal);
-        curEnv->DeleteLocalRef(xLocal);
+}
+
+int ScilabJavaObject::wrap (JavaVM * jvm_, char const* x){
 
-    }
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__java_lang_Stringjava_lang_StringID , x_));
-    curEnv->DeleteLocalRef(stringArrayClass);
-    curEnv->DeleteLocalRef(x_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+jmethodID jintwrapjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "wrap", "(Ljava/lang/String;)I" ) ;
+if (jintwrapjstringjava_lang_StringID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, bool x)
+jstring x_ = curEnv->NewStringUTF( x );
+if (x != NULL && x_ == NULL)
 {
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
 
-    jmethodID jintwrapjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "wrap", "(Z)I" ) ;
-    if (jintwrapjbooleanbooleanID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjstringjava_lang_StringID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    jboolean x_ = (static_cast<bool>(x) ? JNI_TRUE : JNI_FALSE);
+}
+
+int ScilabJavaObject::wrap (JavaVM * jvm_, char const* const* x, int xSize){
+
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbooleanbooleanID , x_));
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+jmethodID jintwrapjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "wrap", "([Ljava/lang/String;)I" ) ;
+if (jintwrapjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+}
+jclass stringArrayClass = curEnv->FindClass("java/lang/String");
 
+// create java array of strings.
+jobjectArray x_ = curEnv->NewObjectArray( xSize, stringArrayClass, NULL);
+if (x_ == NULL)
+{
+throw GiwsException::JniBadAllocException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, bool const* x, int xSize)
+// convert each char * to java strings and fill the java array.
+for ( int i = 0; i < xSize; i++)
 {
+jstring TempString = curEnv->NewStringUTF( x[i] );
+if (TempString == NULL)
+{
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+curEnv->SetObjectArrayElement( x_, i, TempString);
 
-    jmethodID jintwrapjbooleanArray_booleanbooleanID = curEnv->GetStaticMethodID(cls, "wrap", "([Z)I" ) ;
-    if (jintwrapjbooleanArray_booleanbooleanID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+// avoid keeping reference on too many strings
+curEnv->DeleteLocalRef(TempString);
+}
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray_java_lang_Stringjava_lang_StringID ,x_));
+                        curEnv->DeleteLocalRef(stringArrayClass);
+curEnv->DeleteLocalRef(x_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    jbooleanArray x_ = curEnv->NewBooleanArray( xSize ) ;
-    curEnv->SetBooleanArrayRegion( x_, 0, xSize, (jboolean*)x ) ;
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbooleanArray_booleanbooleanID , x_));
-    curEnv->DeleteLocalRef(x_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+int ScilabJavaObject::wrap (JavaVM * jvm_, char const* const* const* x, int xSize, int xSizeCol){
 
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, bool const* const* x, int xSize, int xSizeCol)
+jmethodID jintwrapjobjectArray__java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "wrap", "([[Ljava/lang/String;)I" ) ;
+if (jintwrapjobjectArray__java_lang_Stringjava_lang_StringID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+}
+jclass stringArrayClass = curEnv->FindClass("java/lang/String");
+// create java array of array of strings.
+jobjectArray x_ = curEnv->NewObjectArray( xSize, curEnv->FindClass("[Ljava/lang/String;"), NULL);
+if (x_ == NULL)
 {
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID jintwrapjobjectArray__booleanbooleanID = curEnv->GetStaticMethodID(cls, "wrap", "([[Z)I" ) ;
-    if (jintwrapjobjectArray__booleanbooleanID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
-
-    jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[Z"), NULL);
-    for (int i = 0; i < xSize; i++)
-    {
-        jbooleanArray xLocal = curEnv->NewBooleanArray( xSizeCol ) ;
-        curEnv->SetBooleanArrayRegion( xLocal, 0, xSizeCol, (jboolean*)(x[i]) ) ;
-        curEnv->SetObjectArrayElement(x_, i, xLocal);
-        curEnv->DeleteLocalRef(xLocal);
-    }
-
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__booleanbooleanID , x_));
-    curEnv->DeleteLocalRef(x_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
-
-}
-
-int ScilabJavaObject::wrap (JavaVM * jvm_, unsigned short x)
+for ( int i = 0; i < xSize; i++)
 {
+jobjectArray xLocal = curEnv->NewObjectArray( xSizeCol, stringArrayClass, NULL);
+// convert each char * to java strings and fill the java array.
+for ( int j = 0; j < xSizeCol; j++) {
+jstring TempString = curEnv->NewStringUTF( x[i][j] );
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+if (TempString == NULL)
+{
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    jmethodID jintwrapjcharcharID = curEnv->GetStaticMethodID(cls, "wrap", "(C)I" ) ;
-    if (jintwrapjcharcharID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+curEnv->SetObjectArrayElement( xLocal, j, TempString);
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjcharcharID , x));
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+// avoid keeping reference on too many strings
+curEnv->DeleteLocalRef(TempString);
+}
+curEnv->SetObjectArrayElement(x_, i, xLocal);
+curEnv->DeleteLocalRef(xLocal);
 
 }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__java_lang_Stringjava_lang_StringID ,x_));
+                        curEnv->DeleteLocalRef(stringArrayClass);
+curEnv->DeleteLocalRef(x_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, unsigned short const* x, int xSize)
-{
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+int ScilabJavaObject::wrap (JavaVM * jvm_, bool x){
 
-    jmethodID jintwrapjcharArray_charcharID = curEnv->GetStaticMethodID(cls, "wrap", "([C)I" ) ;
-    if (jintwrapjcharArray_charcharID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
-    jcharArray x_ = curEnv->NewCharArray( xSize ) ;
+jmethodID jintwrapjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "wrap", "(Z)I" ) ;
+if (jintwrapjbooleanbooleanID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+}
 
-    if (x_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+jboolean x_ = (static_cast<bool>(x) ? JNI_TRUE : JNI_FALSE);
 
-    curEnv->SetCharArrayRegion( x_, 0, xSize, (jchar*)(x) ) ;
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbooleanbooleanID ,x_));
+                        curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjcharArray_charcharID , x_));
-    curEnv->DeleteLocalRef(x_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+int ScilabJavaObject::wrap (JavaVM * jvm_, bool const* x, int xSize){
 
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, unsigned short const* const* x, int xSize, int xSizeCol)
-{
+jmethodID jintwrapjbooleanArray_booleanbooleanID = curEnv->GetStaticMethodID(cls, "wrap", "([Z)I" ) ;
+if (jintwrapjbooleanArray_booleanbooleanID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID jintwrapjobjectArray__charcharID = curEnv->GetStaticMethodID(cls, "wrap", "([[C)I" ) ;
-    if (jintwrapjobjectArray__charcharID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
-
-    jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[C"), NULL);
-
-    if (x_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
-
-    for (int i = 0; i < xSize; i++)
-    {
-
-        jcharArray xLocal = curEnv->NewCharArray( xSizeCol ) ;
-
-        if (xLocal == NULL)
-        {
-            // check that allocation succeed
-            curEnv->DeleteLocalRef(x_);
-            throw GiwsException::JniBadAllocException(curEnv);
-        }
+jbooleanArray x_ = curEnv->NewBooleanArray( xSize ) ;
+curEnv->SetBooleanArrayRegion( x_, 0, xSize, (jboolean*)x ) ;
 
-        curEnv->SetCharArrayRegion( xLocal, 0, xSizeCol, (jchar*)(x[i]) ) ;
-        curEnv->SetObjectArrayElement(x_, i, xLocal);
-        curEnv->DeleteLocalRef(xLocal);
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbooleanArray_booleanbooleanID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__charcharID , x_));
-    curEnv->DeleteLocalRef(x_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+}
 
+int ScilabJavaObject::wrap (JavaVM * jvm_, bool const* const* x, int xSize, int xSizeCol){
+
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, float x)
-{
+jmethodID jintwrapjobjectArray__booleanbooleanID = curEnv->GetStaticMethodID(cls, "wrap", "([[Z)I" ) ;
+if (jintwrapjobjectArray__booleanbooleanID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+}
+
+jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[Z"),NULL);
+for (int i=0; i<xSize; i++){
+                        jbooleanArray xLocal = curEnv->NewBooleanArray( xSizeCol ) ;
+                        curEnv->SetBooleanArrayRegion( xLocal, 0, xSizeCol, (jboolean*)(x[i]) ) ;
+                        curEnv->SetObjectArrayElement(x_, i, xLocal);
+                        curEnv->DeleteLocalRef(xLocal);
+                        }
+
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__booleanbooleanID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
+
+}
+
+int ScilabJavaObject::wrap (JavaVM * jvm_, unsigned short x){
+
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+jmethodID jintwrapjcharcharID = curEnv->GetStaticMethodID(cls, "wrap", "(C)I" ) ;
+if (jintwrapjcharcharID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+}
 
-    jmethodID jintwrapjfloatfloatID = curEnv->GetStaticMethodID(cls, "wrap", "(F)I" ) ;
-    if (jintwrapjfloatfloatID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjcharcharID ,x));
+                        curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjfloatfloatID , x));
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+}
+
+int ScilabJavaObject::wrap (JavaVM * jvm_, unsigned short const* x, int xSize){
+
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+jmethodID jintwrapjcharArray_charcharID = curEnv->GetStaticMethodID(cls, "wrap", "([C)I" ) ;
+if (jintwrapjcharArray_charcharID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, float const* x, int xSize)
+jcharArray x_ = curEnv->NewCharArray( xSize ) ;
+
+if (x_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
+
+curEnv->SetCharArrayRegion( x_, 0, xSize, (jchar*)(x) ) ;
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
 
-    jmethodID jintwrapjfloatArray_floatfloatID = curEnv->GetStaticMethodID(cls, "wrap", "([F)I" ) ;
-    if (jintwrapjfloatArray_floatfloatID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjcharArray_charcharID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    jfloatArray x_ = curEnv->NewFloatArray( xSize ) ;
+}
 
-    if (x_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+int ScilabJavaObject::wrap (JavaVM * jvm_, unsigned short const* const* x, int xSize, int xSizeCol){
 
-    curEnv->SetFloatArrayRegion( x_, 0, xSize, (jfloat*)(x) ) ;
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+jmethodID jintwrapjobjectArray__charcharID = curEnv->GetStaticMethodID(cls, "wrap", "([[C)I" ) ;
+if (jintwrapjobjectArray__charcharID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjfloatArray_floatfloatID , x_));
-    curEnv->DeleteLocalRef(x_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+ jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[C"),NULL);
 
+if (x_ == NULL)
+{
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, float const* const* x, int xSize, int xSizeCol)
+ for (int i=0; i<xSize; i++){
+
+jcharArray xLocal = curEnv->NewCharArray( xSizeCol ) ;
+
+if (xLocal == NULL)
 {
+// check that allocation succeed
+curEnv->DeleteLocalRef(x_);
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID jintwrapjobjectArray__floatfloatID = curEnv->GetStaticMethodID(cls, "wrap", "([[F)I" ) ;
-    if (jintwrapjobjectArray__floatfloatID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
-
-    jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[F"), NULL);
-
-    if (x_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
-
-    for (int i = 0; i < xSize; i++)
-    {
-
-        jfloatArray xLocal = curEnv->NewFloatArray( xSizeCol ) ;
-
-        if (xLocal == NULL)
-        {
-            // check that allocation succeed
-            curEnv->DeleteLocalRef(x_);
-            throw GiwsException::JniBadAllocException(curEnv);
-        }
+curEnv->SetCharArrayRegion( xLocal, 0, xSizeCol, (jchar*)(x[i]) ) ;
+curEnv->SetObjectArrayElement(x_, i, xLocal);
+curEnv->DeleteLocalRef(xLocal);
+}
 
-        curEnv->SetFloatArrayRegion( xLocal, 0, xSizeCol, (jfloat*)(x[i]) ) ;
-        curEnv->SetObjectArrayElement(x_, i, xLocal);
-        curEnv->DeleteLocalRef(xLocal);
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__charcharID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
+
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__floatfloatID , x_));
-    curEnv->DeleteLocalRef(x_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+int ScilabJavaObject::wrap (JavaVM * jvm_, float x){
 
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, long long x)
-{
+jmethodID jintwrapjfloatfloatID = curEnv->GetStaticMethodID(cls, "wrap", "(F)I" ) ;
+if (jintwrapjfloatfloatID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjfloatfloatID ,x));
+                        curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    jmethodID jintwrapjlonglongID = curEnv->GetStaticMethodID(cls, "wrap", "(J)I" ) ;
-    if (jintwrapjlonglongID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjlonglongID , x));
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+int ScilabJavaObject::wrap (JavaVM * jvm_, float const* x, int xSize){
 
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, long long const* x, int xSize)
+jmethodID jintwrapjfloatArray_floatfloatID = curEnv->GetStaticMethodID(cls, "wrap", "([F)I" ) ;
+if (jintwrapjfloatArray_floatfloatID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+}
+
+jfloatArray x_ = curEnv->NewFloatArray( xSize ) ;
+
+if (x_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+curEnv->SetFloatArrayRegion( x_, 0, xSize, (jfloat*)(x) ) ;
 
-    jmethodID jintwrapjlongArray_longlongID = curEnv->GetStaticMethodID(cls, "wrap", "([J)I" ) ;
-    if (jintwrapjlongArray_longlongID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
 
-    jlongArray x_ = curEnv->NewLongArray( xSize ) ;
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjfloatArray_floatfloatID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    if (x_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+}
 
-    curEnv->SetLongArrayRegion( x_, 0, xSize, (jlong*)(x) ) ;
+int ScilabJavaObject::wrap (JavaVM * jvm_, float const* const* x, int xSize, int xSizeCol){
 
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjlongArray_longlongID , x_));
-    curEnv->DeleteLocalRef(x_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+jmethodID jintwrapjobjectArray__floatfloatID = curEnv->GetStaticMethodID(cls, "wrap", "([[F)I" ) ;
+if (jintwrapjobjectArray__floatfloatID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+}
+
+ jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[F"),NULL);
 
+if (x_ == NULL)
+{
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, long long const* const* x, int xSize, int xSizeCol)
+ for (int i=0; i<xSize; i++){
+
+jfloatArray xLocal = curEnv->NewFloatArray( xSizeCol ) ;
+
+if (xLocal == NULL)
 {
+// check that allocation succeed
+curEnv->DeleteLocalRef(x_);
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID jintwrapjobjectArray__longlongID = curEnv->GetStaticMethodID(cls, "wrap", "([[J)I" ) ;
-    if (jintwrapjobjectArray__longlongID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
-
-    jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[J"), NULL);
-
-    if (x_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
-
-    for (int i = 0; i < xSize; i++)
-    {
-
-        jlongArray xLocal = curEnv->NewLongArray( xSizeCol ) ;
-
-        if (xLocal == NULL)
-        {
-            // check that allocation succeed
-            curEnv->DeleteLocalRef(x_);
-            throw GiwsException::JniBadAllocException(curEnv);
-        }
+curEnv->SetFloatArrayRegion( xLocal, 0, xSizeCol, (jfloat*)(x[i]) ) ;
+curEnv->SetObjectArrayElement(x_, i, xLocal);
+curEnv->DeleteLocalRef(xLocal);
+}
+
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__floatfloatID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
+
+}
+
+int ScilabJavaObject::wrap (JavaVM * jvm_, long long x){
+
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+
+jmethodID jintwrapjlonglongID = curEnv->GetStaticMethodID(cls, "wrap", "(J)I" ) ;
+if (jintwrapjlonglongID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+}
+
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjlonglongID ,x));
+                        curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-        curEnv->SetLongArrayRegion( xLocal, 0, xSizeCol, (jlong*)(x[i]) ) ;
-        curEnv->SetObjectArrayElement(x_, i, xLocal);
-        curEnv->DeleteLocalRef(xLocal);
-    }
+}
+
+int ScilabJavaObject::wrap (JavaVM * jvm_, long long const* x, int xSize){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__longlongID , x_));
-    curEnv->DeleteLocalRef(x_);
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+jmethodID jintwrapjlongArray_longlongID = curEnv->GetStaticMethodID(cls, "wrap", "([J)I" ) ;
+if (jintwrapjlongArray_longlongID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-char** ScilabJavaObject::getAccessibleFields (JavaVM * jvm_, int id, int *lenRow)
+jlongArray x_ = curEnv->NewLongArray( xSize ) ;
+
+if (x_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID jobjectArray_getAccessibleFieldsjintintID = curEnv->GetStaticMethodID(cls, "getAccessibleFields", "(I)[Ljava/lang/String;" ) ;
-    if (jobjectArray_getAccessibleFieldsjintintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "getAccessibleFields");
-    }
-
-    jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray_getAccessibleFieldsjintintID , id));
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    if (res != NULL)
-    {
-        * lenRow = curEnv->GetArrayLength(res);
-
-        char **arrayOfString;
-        arrayOfString = new char *[*lenRow];
-        for (jsize i = 0; i < *lenRow; i++)
-        {
-            jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
-            const char *tempString = curEnv->GetStringUTFChars(resString, 0);
-            arrayOfString[i] = new char[strlen(tempString) + 1];
-
-            strcpy(arrayOfString[i], tempString);
-            curEnv->ReleaseStringUTFChars(resString, tempString);
-            curEnv->DeleteLocalRef(resString);
-        }
-        curEnv->DeleteLocalRef(cls);
-        if (curEnv->ExceptionCheck())
-        {
-            delete[] arrayOfString;
-            throw GiwsException::JniCallMethodException(curEnv);
-        }
-        curEnv->DeleteLocalRef(res);
-        return arrayOfString;
-    }
-    else
-    {
-        curEnv->DeleteLocalRef(res);
-        return NULL;
-    }
+curEnv->SetLongArrayRegion( x_, 0, xSize, (jlong*)(x) ) ;
+
+
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjlongArray_longlongID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
+
+}
+
+int ScilabJavaObject::wrap (JavaVM * jvm_, long long const* const* x, int xSize, int xSizeCol){
+
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+
+jmethodID jintwrapjobjectArray__longlongID = curEnv->GetStaticMethodID(cls, "wrap", "([[J)I" ) ;
+if (jintwrapjobjectArray__longlongID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-char** ScilabJavaObject::getAccessibleMethods (JavaVM * jvm_, int id, int *lenRow)
+ jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[J"),NULL);
+
+if (x_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID jobjectArray_getAccessibleMethodsjintintID = curEnv->GetStaticMethodID(cls, "getAccessibleMethods", "(I)[Ljava/lang/String;" ) ;
-    if (jobjectArray_getAccessibleMethodsjintintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "getAccessibleMethods");
-    }
-
-    jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray_getAccessibleMethodsjintintID , id));
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    if (res != NULL)
-    {
-        * lenRow = curEnv->GetArrayLength(res);
-
-        char **arrayOfString;
-        arrayOfString = new char *[*lenRow];
-        for (jsize i = 0; i < *lenRow; i++)
-        {
-            jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
-            const char *tempString = curEnv->GetStringUTFChars(resString, 0);
-            arrayOfString[i] = new char[strlen(tempString) + 1];
-
-            strcpy(arrayOfString[i], tempString);
-            curEnv->ReleaseStringUTFChars(resString, tempString);
-            curEnv->DeleteLocalRef(resString);
-        }
-        curEnv->DeleteLocalRef(cls);
-        if (curEnv->ExceptionCheck())
-        {
-            delete[] arrayOfString;
-            throw GiwsException::JniCallMethodException(curEnv);
-        }
-        curEnv->DeleteLocalRef(res);
-        return arrayOfString;
-    }
-    else
-    {
-        curEnv->DeleteLocalRef(res);
-        return NULL;
-    }
+ for (int i=0; i<xSize; i++){
+
+jlongArray xLocal = curEnv->NewLongArray( xSizeCol ) ;
+
+if (xLocal == NULL)
+{
+// check that allocation succeed
+curEnv->DeleteLocalRef(x_);
+throw GiwsException::JniBadAllocException(curEnv);
+}
+
+curEnv->SetLongArrayRegion( xLocal, 0, xSizeCol, (jlong*)(x[i]) ) ;
+curEnv->SetObjectArrayElement(x_, i, xLocal);
+curEnv->DeleteLocalRef(xLocal);
+}
+
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__longlongID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
+return res;
+
+}
+
+char** ScilabJavaObject::getAccessibleFields (JavaVM * jvm_, int id, int *lenRow){
+
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+
+jmethodID jobjectArray_getAccessibleFieldsjintintID = curEnv->GetStaticMethodID(cls, "getAccessibleFields", "(I)[Ljava/lang/String;" ) ;
+if (jobjectArray_getAccessibleFieldsjintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "getAccessibleFields");
+}
+
+                        jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray_getAccessibleFieldsjintintID ,id));
+                        if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}if (res != NULL) { 
+* lenRow = curEnv->GetArrayLength(res);
+
+char **arrayOfString;
+arrayOfString = new char *[*lenRow];
+for (jsize i = 0; i < *lenRow; i++){
+jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
+const char *tempString = curEnv->GetStringUTFChars(resString, 0);
+arrayOfString[i] = new char[strlen(tempString) + 1];
+
+strcpy(arrayOfString[i], tempString);
+curEnv->ReleaseStringUTFChars(resString, tempString);
+curEnv->DeleteLocalRef(resString);
+}
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+delete[] arrayOfString;
+                                throw GiwsException::JniCallMethodException(curEnv);
+}
+curEnv->DeleteLocalRef(res);
+return arrayOfString;
+ } else { 
+curEnv->DeleteLocalRef(res);
+return NULL;
+}
+}
+
+char** ScilabJavaObject::getAccessibleMethods (JavaVM * jvm_, int id, int *lenRow){
 
-char** ScilabJavaObject::getCompletion (JavaVM * jvm_, int id, char const* const* fieldPath, int fieldPathSize, int *lenRow)
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+
+jmethodID jobjectArray_getAccessibleMethodsjintintID = curEnv->GetStaticMethodID(cls, "getAccessibleMethods", "(I)[Ljava/lang/String;" ) ;
+if (jobjectArray_getAccessibleMethodsjintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "getAccessibleMethods");
+}
+
+                        jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray_getAccessibleMethodsjintintID ,id));
+                        if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}if (res != NULL) { 
+* lenRow = curEnv->GetArrayLength(res);
+
+char **arrayOfString;
+arrayOfString = new char *[*lenRow];
+for (jsize i = 0; i < *lenRow; i++){
+jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
+const char *tempString = curEnv->GetStringUTFChars(resString, 0);
+arrayOfString[i] = new char[strlen(tempString) + 1];
+
+strcpy(arrayOfString[i], tempString);
+curEnv->ReleaseStringUTFChars(resString, tempString);
+curEnv->DeleteLocalRef(resString);
+}
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+delete[] arrayOfString;
+                                throw GiwsException::JniCallMethodException(curEnv);
+}
+curEnv->DeleteLocalRef(res);
+return arrayOfString;
+ } else { 
+curEnv->DeleteLocalRef(res);
+return NULL;
+}
+}
+
+char** ScilabJavaObject::getCompletion (JavaVM * jvm_, int id, char const* const* fieldPath, int fieldPathSize, int *lenRow){
+
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+
+jmethodID jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "getCompletion", "(I[Ljava/lang/String;)[Ljava/lang/String;" ) ;
+if (jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "getCompletion");
+}
+jclass stringArrayClass = curEnv->FindClass("java/lang/String");
+
+// create java array of strings.
+jobjectArray fieldPath_ = curEnv->NewObjectArray( fieldPathSize, stringArrayClass, NULL);
+if (fieldPath_ == NULL)
 {
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "getCompletion", "(I[Ljava/lang/String;)[Ljava/lang/String;" ) ;
-    if (jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "getCompletion");
-    }
-    jclass stringArrayClass = curEnv->FindClass("java/lang/String");
-
-    // create java array of strings.
-    jobjectArray fieldPath_ = curEnv->NewObjectArray( fieldPathSize, stringArrayClass, NULL);
-    if (fieldPath_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
-
-    // convert each char * to java strings and fill the java array.
-    for ( int i = 0; i < fieldPathSize; i++)
-    {
-        jstring TempString = curEnv->NewStringUTF( fieldPath[i] );
-        if (TempString == NULL)
-        {
-            throw GiwsException::JniBadAllocException(curEnv);
-        }
+// convert each char * to java strings and fill the java array.
+for ( int i = 0; i < fieldPathSize; i++)
+{
+jstring TempString = curEnv->NewStringUTF( fieldPath[i] );
+if (TempString == NULL)
+{
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-        curEnv->SetObjectArrayElement( fieldPath_, i, TempString);
-
-        // avoid keeping reference on too many strings
-        curEnv->DeleteLocalRef(TempString);
-    }
-    jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID , id, fieldPath_));
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    if (res != NULL)
-    {
-        * lenRow = curEnv->GetArrayLength(res);
-
-        char **arrayOfString;
-        arrayOfString = new char *[*lenRow];
-        for (jsize i = 0; i < *lenRow; i++)
-        {
-            jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
-            const char *tempString = curEnv->GetStringUTFChars(resString, 0);
-            arrayOfString[i] = new char[strlen(tempString) + 1];
-
-            strcpy(arrayOfString[i], tempString);
-            curEnv->ReleaseStringUTFChars(resString, tempString);
-            curEnv->DeleteLocalRef(resString);
-        }
-        curEnv->DeleteLocalRef(stringArrayClass);
-        curEnv->DeleteLocalRef(fieldPath_);
-        curEnv->DeleteLocalRef(cls);
-        if (curEnv->ExceptionCheck())
-        {
-            delete[] arrayOfString;
-            throw GiwsException::JniCallMethodException(curEnv);
-        }
-        curEnv->DeleteLocalRef(res);
-        return arrayOfString;
-    }
-    else
-    {
-        curEnv->DeleteLocalRef(res);
-        return NULL;
-    }
+curEnv->SetObjectArrayElement( fieldPath_, i, TempString);
+
+// avoid keeping reference on too many strings
+curEnv->DeleteLocalRef(TempString);
+}
+                        jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID ,id, fieldPath_));
+                        if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}if (res != NULL) { 
+* lenRow = curEnv->GetArrayLength(res);
+
+char **arrayOfString;
+arrayOfString = new char *[*lenRow];
+for (jsize i = 0; i < *lenRow; i++){
+jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
+const char *tempString = curEnv->GetStringUTFChars(resString, 0);
+arrayOfString[i] = new char[strlen(tempString) + 1];
+
+strcpy(arrayOfString[i], tempString);
+curEnv->ReleaseStringUTFChars(resString, tempString);
+curEnv->DeleteLocalRef(resString);
+}
+curEnv->DeleteLocalRef(stringArrayClass);
+curEnv->DeleteLocalRef(fieldPath_);
+curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+delete[] arrayOfString;
+                                throw GiwsException::JniCallMethodException(curEnv);
+}
+curEnv->DeleteLocalRef(res);
+return arrayOfString;
+ } else { 
+curEnv->DeleteLocalRef(res);
+return NULL;
+}
 }
 
 }
index 48cc2a6..a2903c2 100644 (file)
@@ -1,5 +1,5 @@
 /* Generated by GIWS (version 2.0.2) with command:
-giws -e -f ScilabObjects.giws.xml
+giws -e -f ScilabObjects.giws.xml 
 */
 /*
 
@@ -46,11 +46,11 @@ knowledge of the CeCILL-B license and that you accept its terms.
 
 #include "GiwsException.hxx"
 
-#if defined(_MSC_VER) /* Defined anyway with Visual */
-#include <Windows.h>
-#else
-typedef signed char byte;
-#endif
+        #if defined(_MSC_VER) /* Defined anyway with Visual */
+            #include <Windows.h>
+        #else
+            typedef signed char byte;
+        #endif
 
 
 #ifndef GIWSEXPORT
@@ -69,245 +69,243 @@ typedef signed char byte;
 # endif
 #endif
 
-namespace org_scilab_modules_external_objects_java
-{
-class GIWSEXPORT ScilabJavaObject
-{
+namespace org_scilab_modules_external_objects_java {
+class GIWSEXPORT ScilabJavaObject {
 
 private:
-    JavaVM * jvm;
+JavaVM * jvm;
 
 protected:
-    jmethodID jintinvokejintintjstringjava_lang_StringjintArray_intintID; // cache method id
-    jmethodID jintextractjintintjintArray_intintID; // cache method id
-    jmethodID voidinsertjintintjintArray_intintjintintID; // cache method id
-    jmethodID jobjectArray_getInfosID; // cache method id
-    jmethodID voidinitScilabJavaObjectID; // cache method id
-    jmethodID voidgarbageCollectID; // cache method id
-    jmethodID jstringgetRepresentationjintintID; // cache method id
-    jmethodID jbooleanisValidJavaObjectjintintID; // cache method id
-    jmethodID voidenableTracejstringjava_lang_StringID; // cache method id
-    jmethodID voiddisableTraceID; // cache method id
-    jmethodID voidwriteLogjstringjava_lang_StringID; // cache method id
-    jmethodID voidsetFieldjintintjstringjava_lang_StringjintintID; // cache method id
-    jmethodID jintgetFieldjintintjstringjava_lang_StringID; // cache method id
-    jmethodID jintgetFieldTypejintintjstringjava_lang_StringID; // cache method id
-    jmethodID jintjavaCastjintintjstringjava_lang_StringID; // cache method id
-    jmethodID jintjavaCastjintintjintintID; // cache method id
-    jmethodID jstringgetClassNamejintintID; // cache method id
-    jmethodID jintgetArrayElementjintintjintArray_intintID; // cache method id
-    jmethodID voidsetArrayElementjintintjintArray_intintjintintID; // cache method id
-    jmethodID voidremoveScilabJavaObjectjintintID; // cache method id
-    jmethodID voidremoveScilabJavaObjectjintArray_intintID; // cache method id
-    jmethodID voidlimitDirectBufferjintintID; // cache method id
-    jmethodID jintisUnwrappablejintintID; // cache method id
-    jmethodID jintwrapjdoubledoubleID; // cache method id
-    jmethodID jintwrapjdoubleArray_doubledoubleID; // cache method id
-    jmethodID jintwrapjobjectArray__doubledoubleID; // cache method id
-    jmethodID jintwrapjintintID; // cache method id
-    jmethodID jintwrapjintArray_intintID; // cache method id
-    jmethodID jintwrapjobjectArray__intintID; // cache method id
-    jmethodID jintwrapjbytebyteID; // cache method id
-    jmethodID jintwrapjbyteArray_bytebyteID; // cache method id
-    jmethodID jintwrapjobjectArray__bytebyteID; // cache method id
-    jmethodID jintwrapjshortshortID; // cache method id
-    jmethodID jintwrapjshortArray_shortshortID; // cache method id
-    jmethodID jintwrapjobjectArray__shortshortID; // cache method id
-    jmethodID jintwrapjstringjava_lang_StringID; // cache method id
-    jmethodID jintwrapjobjectArray_java_lang_Stringjava_lang_StringID; // cache method id
-    jclass stringArrayClass;
-    jmethodID jintwrapjobjectArray__java_lang_Stringjava_lang_StringID; // cache method id
-    jmethodID jintwrapjbooleanbooleanID; // cache method id
-    jmethodID jintwrapjbooleanArray_booleanbooleanID; // cache method id
-    jmethodID jintwrapjobjectArray__booleanbooleanID; // cache method id
-    jmethodID jintwrapjcharcharID; // cache method id
-    jmethodID jintwrapjcharArray_charcharID; // cache method id
-    jmethodID jintwrapjobjectArray__charcharID; // cache method id
-    jmethodID jintwrapjfloatfloatID; // cache method id
-    jmethodID jintwrapjfloatArray_floatfloatID; // cache method id
-    jmethodID jintwrapjobjectArray__floatfloatID; // cache method id
-    jmethodID jintwrapjlonglongID; // cache method id
-    jmethodID jintwrapjlongArray_longlongID; // cache method id
-    jmethodID jintwrapjobjectArray__longlongID; // cache method id
-    jmethodID jobjectArray_getAccessibleFieldsjintintID; // cache method id
-    jmethodID jobjectArray_getAccessibleMethodsjintintID; // cache method id
-    jmethodID jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID; // cache method id
-
-
-
-    jobject instance;
-    jclass instanceClass; // cache class
-
-
-    // Caching (if any)
-
-
-    /**
-    * Get the environment matching to the current thread.
-    */
-    virtual JNIEnv * getCurrentEnv();
+jmethodID jintinvokejintintjstringjava_lang_StringjintArray_intintID; // cache method id
+jmethodID jintextractjintintjintArray_intintID; // cache method id
+jmethodID voidinsertjintintjintArray_intintjintintID; // cache method id
+jmethodID jobjectArray_getInfosID; // cache method id
+jmethodID voidinitScilabJavaObjectID; // cache method id
+jmethodID voidgarbageCollectID; // cache method id
+jmethodID jstringgetRepresentationjintintID; // cache method id
+jmethodID jbooleanisValidJavaObjectjintintID; // cache method id
+jmethodID voidenableTracejstringjava_lang_StringID; // cache method id
+jmethodID voiddisableTraceID; // cache method id
+jmethodID voidwriteLogjstringjava_lang_StringID; // cache method id
+jmethodID voidsetFieldjintintjstringjava_lang_StringjintintID; // cache method id
+jmethodID jintgetFieldjintintjstringjava_lang_StringID; // cache method id
+jmethodID jintgetFieldTypejintintjstringjava_lang_StringID; // cache method id
+jmethodID jintjavaCastjintintjstringjava_lang_StringID; // cache method id
+jmethodID jintjavaCastjintintjintintID; // cache method id
+jmethodID jstringgetClassNamejintintID; // cache method id
+jmethodID jintgetArrayElementjintintjintArray_intintID; // cache method id
+jmethodID voidsetArrayElementjintintjintArray_intintjintintID; // cache method id
+jmethodID voidremoveScilabJavaObjectjintintID; // cache method id
+jmethodID voidremoveScilabJavaObjectjintArray_intintID; // cache method id
+jmethodID voidlimitDirectBufferjintintID; // cache method id
+jmethodID jintisUnwrappablejintintID; // cache method id
+jmethodID jintwrapjdoubledoubleID; // cache method id
+jmethodID jintwrapjdoubleArray_doubledoubleID; // cache method id
+jmethodID jintwrapjobjectArray__doubledoubleID; // cache method id
+jmethodID jintwrapjintintID; // cache method id
+jmethodID jintwrapjintArray_intintID; // cache method id
+jmethodID jintwrapjobjectArray__intintID; // cache method id
+jmethodID jintwrapjbytebyteID; // cache method id
+jmethodID jintwrapjbyteArray_bytebyteID; // cache method id
+jmethodID jintwrapjobjectArray__bytebyteID; // cache method id
+jmethodID jintwrapjshortshortID; // cache method id
+jmethodID jintwrapjshortArray_shortshortID; // cache method id
+jmethodID jintwrapjobjectArray__shortshortID; // cache method id
+jmethodID jintwrapjstringjava_lang_StringID; // cache method id
+jmethodID jintwrapjobjectArray_java_lang_Stringjava_lang_StringID; // cache method id
+jclass stringArrayClass;
+jmethodID jintwrapjobjectArray__java_lang_Stringjava_lang_StringID; // cache method id
+jmethodID jintwrapjbooleanbooleanID; // cache method id
+jmethodID jintwrapjbooleanArray_booleanbooleanID; // cache method id
+jmethodID jintwrapjobjectArray__booleanbooleanID; // cache method id
+jmethodID jintwrapjcharcharID; // cache method id
+jmethodID jintwrapjcharArray_charcharID; // cache method id
+jmethodID jintwrapjobjectArray__charcharID; // cache method id
+jmethodID jintwrapjfloatfloatID; // cache method id
+jmethodID jintwrapjfloatArray_floatfloatID; // cache method id
+jmethodID jintwrapjobjectArray__floatfloatID; // cache method id
+jmethodID jintwrapjlonglongID; // cache method id
+jmethodID jintwrapjlongArray_longlongID; // cache method id
+jmethodID jintwrapjobjectArray__longlongID; // cache method id
+jmethodID jobjectArray_getAccessibleFieldsjintintID; // cache method id
+jmethodID jobjectArray_getAccessibleMethodsjintintID; // cache method id
+jmethodID jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID; // cache method id
+
+
+
+jobject instance;
+jclass instanceClass; // cache class
+
+                       
+// Caching (if any)
+
+
+/**
+* Get the environment matching to the current thread.
+*/
+virtual JNIEnv * getCurrentEnv();
 
 public:
-    // Constructor
-    /**
-    * Create a wrapping of the object from a JNIEnv.
-    * It will call the default constructor
-    * @param JEnv_ the Java Env
-    */
-    ScilabJavaObject(JavaVM * jvm_);
-
-    /**
-    * Create a wrapping of an already existing object from a JNIEnv.
-    * The object must have already been instantiated
-    * @param JEnv_ the Java Env
-    * @param JObj the object
-    */
-    ScilabJavaObject(JavaVM * jvm_, jobject JObj);
-
-
-    /**
-    * This is a fake constructor to avoid the constructor
-    * chaining when dealing with extended giws classes
-    */
-#ifdef FAKEGIWSDATATYPE
-    ScilabJavaObject(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
-#endif
+// Constructor
+/**
+* Create a wrapping of the object from a JNIEnv.
+* It will call the default constructor
+* @param JEnv_ the Java Env
+*/
+ScilabJavaObject(JavaVM * jvm_);
+
+/**
+* Create a wrapping of an already existing object from a JNIEnv.
+* The object must have already been instantiated
+* @param JEnv_ the Java Env
+* @param JObj the object
+*/
+ScilabJavaObject(JavaVM * jvm_, jobject JObj);
 
-    // Destructor
-    ~ScilabJavaObject();
 
-    // Generic method
-    // Synchronization methods
-    /**
-    * Enter monitor associated with the object.
-    * Equivalent of creating a "synchronized(obj)" scope in Java.
-    */
-    void synchronize();
+/** 
+* This is a fake constructor to avoid the constructor
+* chaining when dealing with extended giws classes 
+*/
+#ifdef FAKEGIWSDATATYPE
+ScilabJavaObject(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
+#endif
 
-    /**
-    * Exit monitor associated with the object.
-    * Equivalent of ending a "synchronized(obj)" scope.
-    */
-    void endSynchronize();
+// Destructor
+~ScilabJavaObject();
 
-    // Methods
-    static int invoke(JavaVM * jvm_, int id, char const* methodName, int const* args, int argsSize);
+// Generic method
+// Synchronization methods
+/**
+* Enter monitor associated with the object.
+* Equivalent of creating a "synchronized(obj)" scope in Java.
+*/
+void synchronize();
 
-    static int extract(JavaVM * jvm_, int id, int const* args, int argsSize);
+/**
+* Exit monitor associated with the object.
+* Equivalent of ending a "synchronized(obj)" scope.
+*/
+void endSynchronize();
 
-    static void insert(JavaVM * jvm_, int id, int const* keys, int keysSize, int value);
+// Methods
+static int invoke(JavaVM * jvm_, int id, char const* methodName, int const* args, int argsSize);
 
-    static char** getInfos(JavaVM * jvm_, int *lenRow);
+static int extract(JavaVM * jvm_, int id, int const* args, int argsSize);
 
-    static void initScilabJavaObject(JavaVM * jvm_);
+static void insert(JavaVM * jvm_, int id, int const* keys, int keysSize, int value);
 
-    static void garbageCollect(JavaVM * jvm_);
+static char** getInfos(JavaVM * jvm_, int *lenRow);
 
-    static char* getRepresentation(JavaVM * jvm_, int id);
+static void initScilabJavaObject(JavaVM * jvm_);
 
-    static bool isValidJavaObject(JavaVM * jvm_, int id);
+static void garbageCollect(JavaVM * jvm_);
 
-    static void enableTrace(JavaVM * jvm_, char const* filename);
+static char* getRepresentation(JavaVM * jvm_, int id);
 
-    static void disableTrace(JavaVM * jvm_);
+static bool isValidJavaObject(JavaVM * jvm_, int id);
 
-    static void writeLog(JavaVM * jvm_, char const* s);
+static void enableTrace(JavaVM * jvm_, char const* filename);
 
-    static void setField(JavaVM * jvm_, int id, char const* fieldName, int idarg);
+static void disableTrace(JavaVM * jvm_);
 
-    static int getField(JavaVM * jvm_, int id, char const* fieldName);
+static void writeLog(JavaVM * jvm_, char const* s);
 
-    static int getFieldType(JavaVM * jvm_, int id, char const* fieldName);
+static void setField(JavaVM * jvm_, int id, char const* fieldName, int idarg);
 
-    static int javaCast(JavaVM * jvm_, int id, char const* objName);
+static int getField(JavaVM * jvm_, int id, char const* fieldName);
 
-    static int javaCast(JavaVM * jvm_, int id, int classId);
+static int getFieldType(JavaVM * jvm_, int id, char const* fieldName);
 
-    static char* getClassName(JavaVM * jvm_, int id);
+static int javaCast(JavaVM * jvm_, int id, char const* objName);
 
-    static int getArrayElement(JavaVM * jvm_, int id, int const* index, int indexSize);
+static int javaCast(JavaVM * jvm_, int id, int classId);
 
-    static void setArrayElement(JavaVM * jvm_, int id, int const* index, int indexSize, int idArg);
+static char* getClassName(JavaVM * jvm_, int id);
 
-    static void removeScilabJavaObject(JavaVM * jvm_, int id);
+static int getArrayElement(JavaVM * jvm_, int id, int const* index, int indexSize);
 
-    static void removeScilabJavaObject(JavaVM * jvm_, int const* id, int idSize);
+static void setArrayElement(JavaVM * jvm_, int id, int const* index, int indexSize, int idArg);
 
-    static void limitDirectBuffer(JavaVM * jvm_, int id);
+static void removeScilabJavaObject(JavaVM * jvm_, int id);
 
-    static int isUnwrappable(JavaVM * jvm_, int id);
+static void removeScilabJavaObject(JavaVM * jvm_, int const* id, int idSize);
 
-    static int wrap(JavaVM * jvm_, double x);
+static void limitDirectBuffer(JavaVM * jvm_, int id);
 
-    static int wrap(JavaVM * jvm_, double const* x, int xSize);
+static int isUnwrappable(JavaVM * jvm_, int id);
 
-    static int wrap(JavaVM * jvm_, double const* const* x, int xSize, int xSizeCol);
+static int wrap(JavaVM * jvm_, double x);
 
-    static int wrap(JavaVM * jvm_, int x);
+static int wrap(JavaVM * jvm_, double const* x, int xSize);
 
-    static int wrap(JavaVM * jvm_, int const* x, int xSize);
+static int wrap(JavaVM * jvm_, double const* const* x, int xSize, int xSizeCol);
 
-    static int wrap(JavaVM * jvm_, int const* const* x, int xSize, int xSizeCol);
+static int wrap(JavaVM * jvm_, int x);
 
-    static int wrap(JavaVM * jvm_, byte x);
+static int wrap(JavaVM * jvm_, int const* x, int xSize);
 
-    static int wrap(JavaVM * jvm_, byte const* x, int xSize);
+static int wrap(JavaVM * jvm_, int const* const* x, int xSize, int xSizeCol);
 
-    static int wrap(JavaVM * jvm_, byte const* const* x, int xSize, int xSizeCol);
+static int wrap(JavaVM * jvm_, byte x);
 
-    static int wrap(JavaVM * jvm_, short x);
+static int wrap(JavaVM * jvm_, byte const* x, int xSize);
 
-    static int wrap(JavaVM * jvm_, short const* x, int xSize);
+static int wrap(JavaVM * jvm_, byte const* const* x, int xSize, int xSizeCol);
 
-    static int wrap(JavaVM * jvm_, short const* const* x, int xSize, int xSizeCol);
+static int wrap(JavaVM * jvm_, short x);
 
-    static int wrap(JavaVM * jvm_, char const* x);
+static int wrap(JavaVM * jvm_, short const* x, int xSize);
 
-    static int wrap(JavaVM * jvm_, char const* const* x, int xSize);
+static int wrap(JavaVM * jvm_, short const* const* x, int xSize, int xSizeCol);
 
-    static int wrap(JavaVM * jvm_, char const* const* const* x, int xSize, int xSizeCol);
+static int wrap(JavaVM * jvm_, char const* x);
 
-    static int wrap(JavaVM * jvm_, bool x);
+static int wrap(JavaVM * jvm_, char const* const* x, int xSize);
 
-    static int wrap(JavaVM * jvm_, bool const* x, int xSize);
+static int wrap(JavaVM * jvm_, char const* const* const* x, int xSize, int xSizeCol);
 
-    static int wrap(JavaVM * jvm_, bool const* const* x, int xSize, int xSizeCol);
+static int wrap(JavaVM * jvm_, bool x);
 
-    static int wrap(JavaVM * jvm_, unsigned short x);
+static int wrap(JavaVM * jvm_, bool const* x, int xSize);
 
-    static int wrap(JavaVM * jvm_, unsigned short const* x, int xSize);
+static int wrap(JavaVM * jvm_, bool const* const* x, int xSize, int xSizeCol);
 
-    static int wrap(JavaVM * jvm_, unsigned short const* const* x, int xSize, int xSizeCol);
+static int wrap(JavaVM * jvm_, unsigned short x);
 
-    static int wrap(JavaVM * jvm_, float x);
+static int wrap(JavaVM * jvm_, unsigned short const* x, int xSize);
 
-    static int wrap(JavaVM * jvm_, float const* x, int xSize);
+static int wrap(JavaVM * jvm_, unsigned short const* const* x, int xSize, int xSizeCol);
 
-    static int wrap(JavaVM * jvm_, float const* const* x, int xSize, int xSizeCol);
+static int wrap(JavaVM * jvm_, float x);
 
-    static int wrap(JavaVM * jvm_, long long x);
+static int wrap(JavaVM * jvm_, float const* x, int xSize);
 
-    static int wrap(JavaVM * jvm_, long long const* x, int xSize);
+static int wrap(JavaVM * jvm_, float const* const* x, int xSize, int xSizeCol);
 
-    static int wrap(JavaVM * jvm_, long long const* const* x, int xSize, int xSizeCol);
+static int wrap(JavaVM * jvm_, long long x);
 
-    static char** getAccessibleFields(JavaVM * jvm_, int id, int *lenRow);
+static int wrap(JavaVM * jvm_, long long const* x, int xSize);
 
-    static char** getAccessibleMethods(JavaVM * jvm_, int id, int *lenRow);
+static int wrap(JavaVM * jvm_, long long const* const* x, int xSize, int xSizeCol);
 
-    static char** getCompletion(JavaVM * jvm_, int id, char const* const* fieldPath, int fieldPathSize, int *lenRow);
+static char** getAccessibleFields(JavaVM * jvm_, int id, int *lenRow);
 
+static char** getAccessibleMethods(JavaVM * jvm_, int id, int *lenRow);
 
-    /**
-    * Get class name to use for static methods
-    * @return class name to use for static methods
-    */
+static char** getCompletion(JavaVM * jvm_, int id, char const* const* fieldPath, int fieldPathSize, int *lenRow);
 
-    static const std::string className()
-    {
-        return "org/scilab/modules/external_objects_java/ScilabJavaObject";
-    }
 
+                        /**
+                        * Get class name to use for static methods
+                        * @return class name to use for static methods
+                        */
+                        
+                static const std::string className()
+                {
+                return "org/scilab/modules/external_objects_java/ScilabJavaObject";
+                }
+                
 };
 
 
index 06f8774..a6784d4 100644 (file)
         <method name="createJarArchive" returnType="int" modifier="static">
             <param type="String" name="jarFilePath" />
             <param type="String[]" name="filePaths" />
+            <param type="String" name="filesRootPath" />
+            <param type="String" name="manifestFilePath" />
+            <param type="boolean" name="keepAbsolutePaths" />
         </method>
     </object>
 </package>
index 031cb6e..e1afe2b 100644 (file)
@@ -1,6 +1,6 @@
 #include "ScilabOperations.hxx"
 /* Generated by GIWS (version 2.0.2) with command:
-giws -e -f ScilabObjects.giws.xml
+giws -e -f ScilabObjects.giws.xml 
 */
 /*
 
@@ -36,157 +36,136 @@ The fact that you are presently reading this means that you have had
 knowledge of the CeCILL-B license and that you accept its terms.
 */
 
-namespace org_scilab_modules_external_objects_java
-{
-
-// Static declarations (if any)
+namespace org_scilab_modules_external_objects_java {
 
+                // Static declarations (if any)
+                
 // Returns the current env
 
-JNIEnv * ScilabOperations::getCurrentEnv()
-{
-    JNIEnv * curEnv = NULL;
-    jint res = this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    if (res != JNI_OK)
-    {
-        throw GiwsException::JniException(getCurrentEnv());
-    }
-    return curEnv;
+JNIEnv * ScilabOperations::getCurrentEnv() {
+JNIEnv * curEnv = NULL;
+jint res=this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+if (res != JNI_OK) {
+throw GiwsException::JniException(getCurrentEnv());
+}
+return curEnv;
 }
 // Destructor
 
-ScilabOperations::~ScilabOperations()
-{
-    JNIEnv * curEnv = NULL;
-    this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    curEnv->DeleteGlobalRef(this->instance);
-    curEnv->DeleteGlobalRef(this->instanceClass);
+ScilabOperations::~ScilabOperations() {
+JNIEnv * curEnv = NULL;
+this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+curEnv->DeleteGlobalRef(this->instance);
+curEnv->DeleteGlobalRef(this->instanceClass);
 }
 // Constructors
-ScilabOperations::ScilabOperations(JavaVM * jvm_)
-{
-    jmethodID constructObject = NULL ;
-    jobject localInstance ;
-    jclass localClass ;
+ScilabOperations::ScilabOperations(JavaVM * jvm_) {
+jmethodID constructObject = NULL ;
+jobject localInstance ;
+jclass localClass ;
 
-    const std::string construct = "<init>";
-    const std::string param = "()V";
-    jvm = jvm_;
+const std::string construct="<init>";
+const std::string param="()V";
+jvm=jvm_;
 
-    JNIEnv * curEnv = getCurrentEnv();
+JNIEnv * curEnv = getCurrentEnv();
 
-    localClass = curEnv->FindClass( this->className().c_str() ) ;
-    if (localClass == NULL)
-    {
-        throw GiwsException::JniClassNotFoundException(curEnv, this->className());
-    }
-
-    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+localClass = curEnv->FindClass( this->className().c_str() ) ;
+if (localClass == NULL) {
+  throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+}
 
-    /* localClass is not needed anymore */
-    curEnv->DeleteLocalRef(localClass);
+this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
 
-    if (this->instanceClass == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+/* localClass is not needed anymore */
+curEnv->DeleteLocalRef(localClass);
 
+if (this->instanceClass == NULL) {
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
-    if (constructObject == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
 
-    localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
-    if (localInstance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
+if(constructObject == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    this->instance = curEnv->NewGlobalRef(localInstance) ;
-    if (this->instance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-    /* localInstance not needed anymore */
-    curEnv->DeleteLocalRef(localInstance);
+localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
+if(localInstance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+this->instance = curEnv->NewGlobalRef(localInstance) ;
+if(this->instance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+/* localInstance not needed anymore */
+curEnv->DeleteLocalRef(localInstance);
 
-    /* Methods ID set to NULL */
-    jintaddjintintjintintID = NULL;
+                /* Methods ID set to NULL */
+jintaddjintintjintintID=NULL;
 
 
 }
 
-ScilabOperations::ScilabOperations(JavaVM * jvm_, jobject JObj)
-{
-    jvm = jvm_;
+ScilabOperations::ScilabOperations(JavaVM * jvm_, jobject JObj) {
+        jvm=jvm_;
 
-    JNIEnv * curEnv = getCurrentEnv();
+        JNIEnv * curEnv = getCurrentEnv();
 
-    jclass localClass = curEnv->GetObjectClass(JObj);
-    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
-    curEnv->DeleteLocalRef(localClass);
+jclass localClass = curEnv->GetObjectClass(JObj);
+        this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+        curEnv->DeleteLocalRef(localClass);
 
-    if (this->instanceClass == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+        if (this->instanceClass == NULL) {
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+        }
 
-    this->instance = curEnv->NewGlobalRef(JObj) ;
-    if (this->instance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-    /* Methods ID set to NULL */
-    jintaddjintintjintintID = NULL;
+        this->instance = curEnv->NewGlobalRef(JObj) ;
+        if(this->instance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+        }
+        /* Methods ID set to NULL */
+        jintaddjintintjintintID=NULL;
 
 
 }
 
 // Generic methods
 
-void ScilabOperations::synchronize()
-{
-    if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK)
-    {
-        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabOperations");
-    }
+void ScilabOperations::synchronize() {
+if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
+throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabOperations");
+}
 }
 
-void ScilabOperations::endSynchronize()
-{
-    if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK)
-    {
-        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabOperations");
-    }
+void ScilabOperations::endSynchronize() {
+if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
+throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabOperations");
+}
 }
 // Method(s)
 
-int ScilabOperations::add (JavaVM * jvm_, int idA, int idB)
-{
-
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = curEnv->FindClass( className().c_str() );
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-
-    jmethodID jintaddjintintjintintID = curEnv->GetStaticMethodID(cls, "add", "(II)I" ) ;
-    if (jintaddjintintjintintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "add");
-    }
-
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintaddjintintjintintID , idA, idB));
-    curEnv->DeleteLocalRef(cls);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+int ScilabOperations::add (JavaVM * jvm_, int idA, int idB){
+
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = curEnv->FindClass( className().c_str() );
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+
+jmethodID jintaddjintintjintintID = curEnv->GetStaticMethodID(cls, "add", "(II)I" ) ;
+if (jintaddjintintjintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "add");
+}
+
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintaddjintintjintintID ,idA, idB));
+                        curEnv->DeleteLocalRef(cls);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
 }
 
index b72cec0..d3d2be1 100644 (file)
@@ -1,5 +1,5 @@
 /* Generated by GIWS (version 2.0.2) with command:
-giws -e -f ScilabObjects.giws.xml
+giws -e -f ScilabObjects.giws.xml 
 */
 /*
 
@@ -46,11 +46,11 @@ knowledge of the CeCILL-B license and that you accept its terms.
 
 #include "GiwsException.hxx"
 
-#if defined(_MSC_VER) /* Defined anyway with Visual */
-#include <Windows.h>
-#else
-typedef signed char byte;
-#endif
+        #if defined(_MSC_VER) /* Defined anyway with Visual */
+            #include <Windows.h>
+        #else
+            typedef signed char byte;
+        #endif
 
 
 #ifndef GIWSEXPORT
@@ -69,88 +69,86 @@ typedef signed char byte;
 # endif
 #endif
 
-namespace org_scilab_modules_external_objects_java
-{
-class GIWSEXPORT ScilabOperations
-{
+namespace org_scilab_modules_external_objects_java {
+class GIWSEXPORT ScilabOperations {
 
 private:
-    JavaVM * jvm;
+JavaVM * jvm;
 
 protected:
-    jmethodID jintaddjintintjintintID; // cache method id
-
+jmethodID jintaddjintintjintintID; // cache method id
 
 
-    jobject instance;
-    jclass instanceClass; // cache class
 
+jobject instance;
+jclass instanceClass; // cache class
 
-    // Caching (if any)
+                       
+// Caching (if any)
 
 
-    /**
-    * Get the environment matching to the current thread.
-    */
-    virtual JNIEnv * getCurrentEnv();
+/**
+* Get the environment matching to the current thread.
+*/
+virtual JNIEnv * getCurrentEnv();
 
 public:
-    // Constructor
-    /**
-    * Create a wrapping of the object from a JNIEnv.
-    * It will call the default constructor
-    * @param JEnv_ the Java Env
-    */
-    ScilabOperations(JavaVM * jvm_);
-
-    /**
-    * Create a wrapping of an already existing object from a JNIEnv.
-    * The object must have already been instantiated
-    * @param JEnv_ the Java Env
-    * @param JObj the object
-    */
-    ScilabOperations(JavaVM * jvm_, jobject JObj);
-
-
-    /**
-    * This is a fake constructor to avoid the constructor
-    * chaining when dealing with extended giws classes
-    */
-#ifdef FAKEGIWSDATATYPE
-    ScilabOperations(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
-#endif
-
-    // Destructor
-    ~ScilabOperations();
-
-    // Generic method
-    // Synchronization methods
-    /**
-    * Enter monitor associated with the object.
-    * Equivalent of creating a "synchronized(obj)" scope in Java.
-    */
-    void synchronize();
+// Constructor
+/**
+* Create a wrapping of the object from a JNIEnv.
+* It will call the default constructor
+* @param JEnv_ the Java Env
+*/
+ScilabOperations(JavaVM * jvm_);
 
-    /**
-    * Exit monitor associated with the object.
-    * Equivalent of ending a "synchronized(obj)" scope.
-    */
-    void endSynchronize();
+/**
+* Create a wrapping of an already existing object from a JNIEnv.
+* The object must have already been instantiated
+* @param JEnv_ the Java Env
+* @param JObj the object
+*/
+ScilabOperations(JavaVM * jvm_, jobject JObj);
 
-    // Methods
-    static int add(JavaVM * jvm_, int idA, int idB);
 
+/** 
+* This is a fake constructor to avoid the constructor
+* chaining when dealing with extended giws classes 
+*/
+#ifdef FAKEGIWSDATATYPE
+ScilabOperations(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
+#endif
 
-    /**
-    * Get class name to use for static methods
-    * @return class name to use for static methods
-    */
+// Destructor
+~ScilabOperations();
 
-    static const std::string className()
-    {
-        return "org/scilab/modules/external_objects_java/ScilabOperations";
-    }
+// Generic method
+// Synchronization methods
+/**
+* Enter monitor associated with the object.
+* Equivalent of creating a "synchronized(obj)" scope in Java.
+*/
+void synchronize();
 
+/**
+* Exit monitor associated with the object.
+* Equivalent of ending a "synchronized(obj)" scope.
+*/
+void endSynchronize();
+
+// Methods
+static int add(JavaVM * jvm_, int idA, int idB);
+
+
+                        /**
+                        * Get class name to use for static methods
+                        * @return class name to use for static methods
+                        */
+                        
+                static const std::string className()
+                {
+                return "org/scilab/modules/external_objects_java/ScilabOperations";
+                }
+                
 };