Update giws files with version 2.0.2 to improve performances: 42/13142/2
Calixte DENIZET [Wed, 13 Nov 2013 10:53:39 +0000 (11:53 +0100)]
i) f=gcf();t=[];for j=1:100;tic();for i=1:10000;set(f,"background",-2);end;t=[t toc()];end;mean(t)

ii) c=jcompile("foo","public class foo { public static double inc(double x) {return x+1;}}");t=[];for j=1:100;tic(); for i=1:10000;jinvoke(c,"inc",10);end;t=[t toc()];end;mean(t)

In first case the gain is 28% and in the second one it is 43%

Change-Id: I2757396f8184a69080ae5f978bfbad0e98ed8c57

92 files changed:
scilab/modules/action_binding/src/jni/Signal.cpp
scilab/modules/action_binding/src/jni/Signal.hxx
scilab/modules/commons/src/jni/GiwsException.cpp
scilab/modules/commons/src/jni/GiwsException.hxx
scilab/modules/console/src/jni/CallScilabBridge.cpp
scilab/modules/console/src/jni/CallScilabBridge.hxx
scilab/modules/external_objects_java/src/jni/ScilabClassLoader.cpp
scilab/modules/external_objects_java/src/jni/ScilabClassLoader.hxx
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/ScilabJavaArray.cpp
scilab/modules/external_objects_java/src/jni/ScilabJavaArray.hxx
scilab/modules/external_objects_java/src/jni/ScilabJavaClass.cpp
scilab/modules/external_objects_java/src/jni/ScilabJavaClass.hxx
scilab/modules/external_objects_java/src/jni/ScilabJavaCompiler.cpp
scilab/modules/external_objects_java/src/jni/ScilabJavaCompiler.hxx
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/ScilabOperations.cpp
scilab/modules/external_objects_java/src/jni/ScilabOperations.hxx
scilab/modules/graphic_export/src/jni/Driver.cpp
scilab/modules/graphic_export/src/jni/Driver.hxx
scilab/modules/graphic_export/src/jni/FileExporter.cpp
scilab/modules/graphic_export/src/jni/FileExporter.hxx
scilab/modules/graphic_objects/src/jni/CallGraphicController.cpp
scilab/modules/graphic_objects/src/jni/CallGraphicController.hxx
scilab/modules/graphic_objects/src/jni/GraphicObjectBuilder.cpp
scilab/modules/graphic_objects/src/jni/GraphicObjectBuilder.hxx
scilab/modules/gui/src/jni/CallScilabBridge.cpp
scilab/modules/gui/src/jni/CallScilabBridge.hxx
scilab/modules/gui/src/jni/DatatipCreate.cpp
scilab/modules/gui/src/jni/DatatipCreate.hxx
scilab/modules/gui/src/jni/DatatipDelete.cpp
scilab/modules/gui/src/jni/DatatipDelete.hxx
scilab/modules/gui/src/jni/DatatipDrag.cpp
scilab/modules/gui/src/jni/DatatipDrag.hxx
scilab/modules/gui/src/jni/DatatipManager.cpp
scilab/modules/gui/src/jni/DatatipManager.hxx
scilab/modules/gui/src/jni/DatatipOrientation.cpp
scilab/modules/gui/src/jni/DatatipOrientation.hxx
scilab/modules/gui/src/jni/DatatipSetStyle.cpp
scilab/modules/gui/src/jni/DatatipSetStyle.hxx
scilab/modules/gui/src/jni/EditorManager.cpp
scilab/modules/gui/src/jni/EditorManager.hxx
scilab/modules/gui/src/jni/Juigetfile.cpp
scilab/modules/gui/src/jni/Juigetfile.hxx
scilab/modules/gui/src/jni/Jxclick.cpp
scilab/modules/gui/src/jni/Jxclick.hxx
scilab/modules/gui/src/jni/Jxgetmouse.cpp
scilab/modules/gui/src/jni/Jxgetmouse.hxx
scilab/modules/gui/src/jni/LookAndFeelManager.cpp
scilab/modules/gui/src/jni/LookAndFeelManager.hxx
scilab/modules/gui/src/jni/ScilabDisplayTree.cpp
scilab/modules/gui/src/jni/ScilabDisplayTree.hxx
scilab/modules/gui/src/jni/StartGED.cpp
scilab/modules/gui/src/jni/StartGED.hxx
scilab/modules/gui/src/jni/StartPlotBrowser.cpp
scilab/modules/gui/src/jni/StartPlotBrowser.hxx
scilab/modules/gui/src/jni/SwingView.cpp
scilab/modules/gui/src/jni/SwingView.hxx
scilab/modules/helptools/src/jni/BuildDocObject.cpp
scilab/modules/helptools/src/jni/BuildDocObject.hxx
scilab/modules/helptools/src/jni/SciDocMain.cpp
scilab/modules/helptools/src/jni/SciDocMain.hxx
scilab/modules/history_browser/src/jni/CommandHistory.cpp
scilab/modules/history_browser/src/jni/CommandHistory.hxx
scilab/modules/preferences/src/jni/ScilabPreferences.cpp
scilab/modules/preferences/src/jni/ScilabPreferences.hxx
scilab/modules/renderer/src/jni/CallRenderer.cpp
scilab/modules/renderer/src/jni/CallRenderer.hxx
scilab/modules/renderer/src/jni/XlFontManager.cpp
scilab/modules/renderer/src/jni/XlFontManager.hxx
scilab/modules/scicos_blocks/src/jni/AfficheBlock.cpp
scilab/modules/scicos_blocks/src/jni/AfficheBlock.hxx
scilab/modules/scinotes/src/jni/SciNotes.cpp
scilab/modules/scinotes/src/jni/SciNotes.hxx
scilab/modules/types/src/jni/ScilabVariables.cpp
scilab/modules/types/src/jni/ScilabVariables.hxx
scilab/modules/types/src/jni/ScilabVariablesRefresh.cpp
scilab/modules/types/src/jni/ScilabVariablesRefresh.hxx
scilab/modules/ui_data/src/jni/BrowseVar.cpp
scilab/modules/ui_data/src/jni/BrowseVar.hxx
scilab/modules/ui_data/src/jni/EditVar.cpp
scilab/modules/ui_data/src/jni/EditVar.hxx
scilab/modules/ui_data/src/jni/FileBrowser.cpp
scilab/modules/ui_data/src/jni/FileBrowser.hxx
scilab/modules/xcos/src/jni/Modelica.cpp
scilab/modules/xcos/src/jni/Modelica.hxx
scilab/modules/xcos/src/jni/Palette.cpp
scilab/modules/xcos/src/jni/Palette.hxx
scilab/modules/xcos/src/jni/Xcos.cpp
scilab/modules/xcos/src/jni/Xcos.hxx

index 65f5cb9..9513543 100644 (file)
@@ -1,6 +1,6 @@
 #include "Signal.hxx"
-/* Generated by GIWS (version 2.0.1) with command:
-giws --disable-return-size-array --output-dir D:\git\debug\similan\scilab\modules\action_binding\src\jni\ --throws-exception-on-error --description-file Signal.giws.xml 
+/* Generated by GIWS (version 2.0.2) with command:
+giws --disable-return-size-array --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/Signal.giws.xml
 */
 /*
 
@@ -10,16 +10,16 @@ This software is a computer program whose purpose is to hide the complexity
 of accessing Java objects/methods from C++ code.
 
 This software is governed by the CeCILL-B license under French law and
-abiding by the rules of distribution of free software.  You can  use, 
+abiding by the rules of distribution of free software.  You can  use,
 modify and/ or redistribute the software under the terms of the CeCILL-B
 license as circulated by CEA, CNRS and INRIA at the following URL
-"http://www.cecill.info". 
+"http://www.cecill.info".
 
 As a counterpart to the access to the source code and  rights to copy,
 modify and redistribute granted by the license, users are provided only
 with a limited warranty  and the software's author,  the holder of the
 economic rights,  and the successive licensors  have only  limited
-liability. 
+liability.
 
 In this respect, the user's attention is drawn to the risks associated
 with loading,  using,  modifying and/or developing or reproducing the
@@ -28,149 +28,171 @@ that may mean  that it is complicated to manipulate,  and  that  also
 therefore means  that it is reserved for developers  and  experienced
 professionals having in-depth computer knowledge. Users are therefore
 encouraged to load and test the software's suitability as regards their
-requirements in conditions enabling the security of their systems and/or 
-data to be ensured and,  more generally, to use and operate it in the 
-same conditions as regards security. 
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
 
 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_action_binding_utils {
+namespace org_scilab_modules_action_binding_utils
+{
+
+// Static declarations (if any)
 
-                // Static declarations (if any)
-                
 // Returns the current env
 
-JNIEnv * Signal::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 * Signal::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
 
-Signal::~Signal() {
-JNIEnv * curEnv = NULL;
-this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-
-curEnv->DeleteGlobalRef(this->instance);
-curEnv->DeleteGlobalRef(this->instanceClass);
+Signal::~Signal()
+{
+    JNIEnv * curEnv = NULL;
+    this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    curEnv->DeleteGlobalRef(this->instance);
+    curEnv->DeleteGlobalRef(this->instanceClass);
 }
 // Constructors
-Signal::Signal(JavaVM * jvm_) {
-jmethodID constructObject = NULL ;
-jobject localInstance ;
-jclass localClass ;
+Signal::Signal(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());
-}
+    localClass = curEnv->FindClass( this->className().c_str() ) ;
+    if (localClass == NULL)
+    {
+        throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+    }
 
-this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
 
-/* localClass is not needed anymore */
-curEnv->DeleteLocalRef(localClass);
+    /* localClass is not needed anymore */
+    curEnv->DeleteLocalRef(localClass);
 
-if (this->instanceClass == NULL) {
-throw GiwsException::JniObjectCreationException(curEnv, this->className());
-}
+    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());
-}
+    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);
+    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 */
-voidnotifyjstringjava_lang_StringID=NULL;
+    /* Methods ID set to NULL */
+    voidnotifyjstringjava_lang_StringID = NULL;
 
 
 }
 
-Signal::Signal(JavaVM * jvm_, jobject JObj) {
-        jvm=jvm_;
+Signal::Signal(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 */
-        voidnotifyjstringjava_lang_StringID=NULL;
+    this->instance = curEnv->NewGlobalRef(JObj) ;
+    if (this->instance == NULL)
+    {
+        throw GiwsException::JniObjectCreationException(curEnv, this->className());
+    }
+    /* Methods ID set to NULL */
+    voidnotifyjstringjava_lang_StringID = NULL;
 
 
 }
 
 // Generic methods
 
-void Signal::synchronize() {
-if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
-throw GiwsException::JniMonitorException(getCurrentEnv(), "Signal");
-}
+void Signal::synchronize()
+{
+    if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK)
+    {
+        throw GiwsException::JniMonitorException(getCurrentEnv(), "Signal");
+    }
 }
 
-void Signal::endSynchronize() {
-if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
-throw GiwsException::JniMonitorException(getCurrentEnv(), "Signal");
-}
+void Signal::endSynchronize()
+{
+    if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK)
+    {
+        throw GiwsException::JniMonitorException(getCurrentEnv(), "Signal");
+    }
 }
 // Method(s)
 
-void Signal::notify (JavaVM * jvm_, char const* ID){
-
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
-
-jmethodID voidnotifyjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "notify", "(Ljava/lang/String;)V" ) ;
-if (voidnotifyjstringjava_lang_StringID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "notify");
-}
-
-jstring ID_ = curEnv->NewStringUTF( ID );
-if (ID != NULL && ID_ == NULL)
+void Signal::notify (JavaVM * jvm_, char const* ID)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
-
 
-                         curEnv->CallStaticVoidMethod(cls, voidnotifyjstringjava_lang_StringID ,ID_);
-                        curEnv->DeleteLocalRef(ID_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static jmethodID voidnotifyjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "notify", "(Ljava/lang/String;)V" ) ;
+    if (voidnotifyjstringjava_lang_StringID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "notify");
+    }
+
+    jstring ID_ = curEnv->NewStringUTF( ID );
+    if (ID != NULL && ID_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+
+    curEnv->CallStaticVoidMethod(cls, voidnotifyjstringjava_lang_StringID , ID_);
+    curEnv->DeleteLocalRef(ID_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
 }
index 9b71be8..8e50809 100644 (file)
@@ -1,5 +1,5 @@
-/* Generated by GIWS (version 2.0.1) with command:
-giws --disable-return-size-array --output-dir D:\git\debug\similan\scilab\modules\action_binding\src\jni\ --throws-exception-on-error --description-file Signal.giws.xml 
+/* Generated by GIWS (version 2.0.2) with command:
+giws --disable-return-size-array --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/Signal.giws.xml
 */
 /*
 
@@ -9,16 +9,16 @@ This software is a computer program whose purpose is to hide the complexity
 of accessing Java objects/methods from C++ code.
 
 This software is governed by the CeCILL-B license under French law and
-abiding by the rules of distribution of free software.  You can  use, 
+abiding by the rules of distribution of free software.  You can  use,
 modify and/ or redistribute the software under the terms of the CeCILL-B
 license as circulated by CEA, CNRS and INRIA at the following URL
-"http://www.cecill.info". 
+"http://www.cecill.info".
 
 As a counterpart to the access to the source code and  rights to copy,
 modify and redistribute granted by the license, users are provided only
 with a limited warranty  and the software's author,  the holder of the
 economic rights,  and the successive licensors  have only  limited
-liability. 
+liability.
 
 In this respect, the user's attention is drawn to the risks associated
 with loading,  using,  modifying and/or developing or reproducing the
@@ -27,9 +27,9 @@ that may mean  that it is complicated to manipulate,  and  that  also
 therefore means  that it is reserved for developers  and  experienced
 professionals having in-depth computer knowledge. Users are therefore
 encouraged to load and test the software's suitability as regards their
-requirements in conditions enabling the security of their systems and/or 
-data to be ensured and,  more generally, to use and operate it in the 
-same conditions as regards security. 
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
 
 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.
@@ -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,86 +69,110 @@ knowledge of the CeCILL-B license and that you accept its terms.
 # endif
 #endif
 
-namespace org_scilab_modules_action_binding_utils {
-class GIWSEXPORT Signal {
+namespace org_scilab_modules_action_binding_utils
+{
+class GIWSEXPORT Signal
+{
 
 private:
-JavaVM * jvm;
+    JavaVM * jvm;
 
 protected:
-jmethodID voidnotifyjstringjava_lang_StringID; // cache method id
+    jmethodID voidnotifyjstringjava_lang_StringID; // 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
-*/
-Signal(JavaVM * jvm_);
+    // Constructor
+    /**
+    * Create a wrapping of the object from a JNIEnv.
+    * It will call the default constructor
+    * @param JEnv_ the Java Env
+    */
+    Signal(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
+    */
+    Signal(JavaVM * jvm_, jobject JObj);
+
+
+    /**
+    * This is a fake constructor to avoid the constructor
+    * chaining when dealing with extended giws classes
+    */
+#ifdef FAKEGIWSDATATYPE
+    Signal(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
+#endif
 
-/**
-* 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
-*/
-Signal(JavaVM * jvm_, jobject JObj);
+    // Destructor
+    ~Signal();
 
+    // 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
-Signal(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
-#endif
+    /**
+    * Exit monitor associated with the object.
+    * Equivalent of ending a "synchronized(obj)" scope.
+    */
+    void endSynchronize();
 
-// Destructor
-~Signal();
+    // Methods
+    static void notify(JavaVM * jvm_, char const* ID);
 
-// 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 void notify(JavaVM * jvm_, char const* ID);
-
-
-                        /**
-                        * 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/action_binding/utils/Signal";
-                }
-                
+    /**
+    * 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/action_binding/utils/Signal";
+    }
+
+
+    /**
+    * Get class to use for static methods
+    * @return class to use for static methods
+    */
+
+    static jclass initClass(JNIEnv * curEnv)
+    {
+        static jclass cls = 0;
+
+        if (cls == 0)
+        {
+            jclass _cls = curEnv->FindClass(className().c_str());
+            if (_cls)
+            {
+                cls = static_cast<jclass>(curEnv->NewGlobalRef(_cls));
+            }
+        }
+
+        return cls;
+    }
+
 };
 
 
index 0de9ca8..d4c8fa1 100644 (file)
@@ -1,4 +1,4 @@
-/* Generated by GIWS (version 2.0.1) */
+/* Generated by GIWS (version 2.0.2) */
 /*
 
 This is generated code.
index ff5e870..3cb4e5f 100644 (file)
@@ -1,4 +1,4 @@
-/* Generated by GIWS (version 2.0.1) */
+/* Generated by GIWS (version 2.0.2) */
 /*
 
 This is generated code.
index 4b708ba..d1cb164 100644 (file)
@@ -1,6 +1,6 @@
 #include "CallScilabBridge.hxx"
-/* Generated by GIWS (version 2.0.1) with command:
-giws --disable-return-size-array --output-dir D:\git\debug\similan\scilab\modules\console\src\jni\ --throws-exception-on-error --description-file CallScilabBridge.giws.xml 
+/* Generated by GIWS (version 2.0.2) with command:
+giws --disable-return-size-array --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/CallScilabBridge.giws.xml
 */
 /*
 
@@ -10,16 +10,16 @@ This software is a computer program whose purpose is to hide the complexity
 of accessing Java objects/methods from C++ code.
 
 This software is governed by the CeCILL-B license under French law and
-abiding by the rules of distribution of free software.  You can  use, 
+abiding by the rules of distribution of free software.  You can  use,
 modify and/ or redistribute the software under the terms of the CeCILL-B
 license as circulated by CEA, CNRS and INRIA at the following URL
-"http://www.cecill.info". 
+"http://www.cecill.info".
 
 As a counterpart to the access to the source code and  rights to copy,
 modify and redistribute granted by the license, users are provided only
 with a limited warranty  and the software's author,  the holder of the
 economic rights,  and the successive licensors  have only  limited
-liability. 
+liability.
 
 In this respect, the user's attention is drawn to the risks associated
 with loading,  using,  modifying and/or developing or reproducing the
@@ -28,343 +28,418 @@ that may mean  that it is complicated to manipulate,  and  that  also
 therefore means  that it is reserved for developers  and  experienced
 professionals having in-depth computer knowledge. Users are therefore
 encouraged to load and test the software's suitability as regards their
-requirements in conditions enabling the security of their systems and/or 
-data to be ensured and,  more generally, to use and operate it in the 
-same conditions as regards security. 
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
 
 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_gui_bridge {
+namespace org_scilab_modules_gui_bridge
+{
+
+// Static declarations (if any)
 
-                // Static declarations (if any)
-                
 // Returns the current env
 
-JNIEnv * CallScilabBridge::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 * CallScilabBridge::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
 
-CallScilabBridge::~CallScilabBridge() {
-JNIEnv * curEnv = NULL;
-this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-
-curEnv->DeleteGlobalRef(this->instance);
-curEnv->DeleteGlobalRef(this->instanceClass);
+CallScilabBridge::~CallScilabBridge()
+{
+    JNIEnv * curEnv = NULL;
+    this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    curEnv->DeleteGlobalRef(this->instance);
+    curEnv->DeleteGlobalRef(this->instanceClass);
 }
 // Constructors
-CallScilabBridge::CallScilabBridge(JavaVM * jvm_) {
-jmethodID constructObject = NULL ;
-jobject localInstance ;
-jclass localClass ;
+CallScilabBridge::CallScilabBridge(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());
-}
+    localClass = curEnv->FindClass( this->className().c_str() ) ;
+    if (localClass == NULL)
+    {
+        throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+    }
 
-this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
 
-/* localClass is not needed anymore */
-curEnv->DeleteLocalRef(localClass);
+    /* localClass is not needed anymore */
+    curEnv->DeleteLocalRef(localClass);
 
-if (this->instanceClass == NULL) {
-throw GiwsException::JniObjectCreationException(curEnv, this->className());
-}
+    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());
-}
+    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);
+    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 */
-voiddisplayjstringjava_lang_StringID=NULL;
-jstringreadLineID=NULL;
-voidclearID=NULL;
-voidclearjintintID=NULL;
-jintgetCharWithoutOutputID=NULL;
-voidtoHomeID=NULL;
-voidscilabLinesUpdateID=NULL;
-voidsetPromptjstringjava_lang_StringID=NULL;
-jbooleanisWaitingForInputID=NULL;
+    /* Methods ID set to NULL */
+    voiddisplayjstringjava_lang_StringID = NULL;
+    jstringreadLineID = NULL;
+    voidclearID = NULL;
+    voidclearjintintID = NULL;
+    jintgetCharWithoutOutputID = NULL;
+    voidtoHomeID = NULL;
+    voidscilabLinesUpdateID = NULL;
+    voidsetPromptjstringjava_lang_StringID = NULL;
+    jbooleanisWaitingForInputID = NULL;
 
 
 }
 
-CallScilabBridge::CallScilabBridge(JavaVM * jvm_, jobject JObj) {
-        jvm=jvm_;
+CallScilabBridge::CallScilabBridge(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 */
-        voiddisplayjstringjava_lang_StringID=NULL;
-jstringreadLineID=NULL;
-voidclearID=NULL;
-voidclearjintintID=NULL;
-jintgetCharWithoutOutputID=NULL;
-voidtoHomeID=NULL;
-voidscilabLinesUpdateID=NULL;
-voidsetPromptjstringjava_lang_StringID=NULL;
-jbooleanisWaitingForInputID=NULL;
+    this->instance = curEnv->NewGlobalRef(JObj) ;
+    if (this->instance == NULL)
+    {
+        throw GiwsException::JniObjectCreationException(curEnv, this->className());
+    }
+    /* Methods ID set to NULL */
+    voiddisplayjstringjava_lang_StringID = NULL;
+    jstringreadLineID = NULL;
+    voidclearID = NULL;
+    voidclearjintintID = NULL;
+    jintgetCharWithoutOutputID = NULL;
+    voidtoHomeID = NULL;
+    voidscilabLinesUpdateID = NULL;
+    voidsetPromptjstringjava_lang_StringID = NULL;
+    jbooleanisWaitingForInputID = NULL;
 
 
 }
 
 // Generic methods
 
-void CallScilabBridge::synchronize() {
-if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
-throw GiwsException::JniMonitorException(getCurrentEnv(), "CallScilabBridge");
-}
+void CallScilabBridge::synchronize()
+{
+    if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK)
+    {
+        throw GiwsException::JniMonitorException(getCurrentEnv(), "CallScilabBridge");
+    }
 }
 
-void CallScilabBridge::endSynchronize() {
-if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
-throw GiwsException::JniMonitorException(getCurrentEnv(), "CallScilabBridge");
-}
+void CallScilabBridge::endSynchronize()
+{
+    if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK)
+    {
+        throw GiwsException::JniMonitorException(getCurrentEnv(), "CallScilabBridge");
+    }
 }
 // Method(s)
 
-void CallScilabBridge::display (JavaVM * jvm_, char const* dataToDisplay){
-
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
-
-jmethodID voiddisplayjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "display", "(Ljava/lang/String;)V" ) ;
-if (voiddisplayjstringjava_lang_StringID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "display");
-}
-
-jstring dataToDisplay_ = curEnv->NewStringUTF( dataToDisplay );
-if (dataToDisplay != NULL && dataToDisplay_ == NULL)
+void CallScilabBridge::display (JavaVM * jvm_, char const* dataToDisplay)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
-
-
-                         curEnv->CallStaticVoidMethod(cls, voiddisplayjstringjava_lang_StringID ,dataToDisplay_);
-                        curEnv->DeleteLocalRef(dataToDisplay_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
 
-char* CallScilabBridge::readLine (JavaVM * jvm_){
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
+    static jmethodID voiddisplayjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "display", "(Ljava/lang/String;)V" ) ;
+    if (voiddisplayjstringjava_lang_StringID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "display");
+    }
 
-jmethodID jstringreadLineID = curEnv->GetStaticMethodID(cls, "readLine", "()Ljava/lang/String;" ) ;
-if (jstringreadLineID == NULL) {
+    jstring dataToDisplay_ = curEnv->NewStringUTF( dataToDisplay );
+    if (dataToDisplay != NULL && dataToDisplay_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-jvm_->DetachCurrentThread();
-throw GiwsException::JniMethodNotFoundException(curEnv, "readLine");
-}
 
-                        jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringreadLineID ));
-                        if (curEnv->ExceptionCheck()) {
-
-jvm_->DetachCurrentThread();
-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;
-                                
-jvm_->DetachCurrentThread();
-throw GiwsException::JniCallMethodException(curEnv);
+    curEnv->CallStaticVoidMethod(cls, voiddisplayjstringjava_lang_StringID , dataToDisplay_);
+    curEnv->DeleteLocalRef(dataToDisplay_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
-jvm_->DetachCurrentThread();
 
-return myStringBuffer;
- } else { 
-curEnv->DeleteLocalRef(res);
-return NULL;
-}
-}
-
-void CallScilabBridge::clear (JavaVM * jvm_){
+char* CallScilabBridge::readLine (JavaVM * jvm_)
+{
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static jmethodID jstringreadLineID = curEnv->GetStaticMethodID(cls, "readLine", "()Ljava/lang/String;" ) ;
+    if (jstringreadLineID == NULL)
+    {
+
+        jvm_->DetachCurrentThread();
+        throw GiwsException::JniMethodNotFoundException(curEnv, "readLine");
+    }
+
+    jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringreadLineID ));
+    if (curEnv->ExceptionCheck())
+    {
+
+        jvm_->DetachCurrentThread();
+        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);
+        if (curEnv->ExceptionCheck())
+        {
+            delete[] myStringBuffer;
+
+            jvm_->DetachCurrentThread();
+            throw GiwsException::JniCallMethodException(curEnv);
+        }
+        jvm_->DetachCurrentThread();
 
-jmethodID voidclearID = curEnv->GetStaticMethodID(cls, "clear", "()V" ) ;
-if (voidclearID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "clear");
+        return myStringBuffer;
+    }
+    else
+    {
+        curEnv->DeleteLocalRef(res);
+        return NULL;
+    }
 }
 
-                         curEnv->CallStaticVoidMethod(cls, voidclearID );
-                        curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+void CallScilabBridge::clear (JavaVM * jvm_)
+{
 
-void CallScilabBridge::clear (JavaVM * jvm_, int nbLines){
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
+    static jmethodID voidclearID = curEnv->GetStaticMethodID(cls, "clear", "()V" ) ;
+    if (voidclearID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "clear");
+    }
 
-jmethodID voidclearjintintID = curEnv->GetStaticMethodID(cls, "clear", "(I)V" ) ;
-if (voidclearjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "clear");
+    curEnv->CallStaticVoidMethod(cls, voidclearID );
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-                         curEnv->CallStaticVoidMethod(cls, voidclearjintintID ,nbLines);
-                        curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+void CallScilabBridge::clear (JavaVM * jvm_, int nbLines)
+{
 
-int CallScilabBridge::getCharWithoutOutput (JavaVM * jvm_){
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
+    static jmethodID voidclearjintintID = curEnv->GetStaticMethodID(cls, "clear", "(I)V" ) ;
+    if (voidclearjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "clear");
+    }
 
-jmethodID jintgetCharWithoutOutputID = curEnv->GetStaticMethodID(cls, "getCharWithoutOutput", "()I" ) ;
-if (jintgetCharWithoutOutputID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "getCharWithoutOutput");
+    curEnv->CallStaticVoidMethod(cls, voidclearjintintID , nbLines);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetCharWithoutOutputID ));
-                        curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-return res;
+int CallScilabBridge::getCharWithoutOutput (JavaVM * jvm_)
+{
 
-}
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-void CallScilabBridge::toHome (JavaVM * jvm_){
+    static jmethodID jintgetCharWithoutOutputID = curEnv->GetStaticMethodID(cls, "getCharWithoutOutput", "()I" ) ;
+    if (jintgetCharWithoutOutputID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "getCharWithoutOutput");
+    }
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
+    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetCharWithoutOutputID ));
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-jmethodID voidtoHomeID = curEnv->GetStaticMethodID(cls, "toHome", "()V" ) ;
-if (voidtoHomeID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "toHome");
 }
 
-                         curEnv->CallStaticVoidMethod(cls, voidtoHomeID );
-                        curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+void CallScilabBridge::toHome (JavaVM * jvm_)
+{
 
-void CallScilabBridge::scilabLinesUpdate (JavaVM * jvm_){
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
+    static jmethodID voidtoHomeID = curEnv->GetStaticMethodID(cls, "toHome", "()V" ) ;
+    if (voidtoHomeID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "toHome");
+    }
 
-jmethodID voidscilabLinesUpdateID = curEnv->GetStaticMethodID(cls, "scilabLinesUpdate", "()V" ) ;
-if (voidscilabLinesUpdateID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "scilabLinesUpdate");
+    curEnv->CallStaticVoidMethod(cls, voidtoHomeID );
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-                         curEnv->CallStaticVoidMethod(cls, voidscilabLinesUpdateID );
-                        curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+void CallScilabBridge::scilabLinesUpdate (JavaVM * jvm_)
+{
 
-void CallScilabBridge::setPrompt (JavaVM * jvm_, char const* promptToSet){
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
+    static jmethodID voidscilabLinesUpdateID = curEnv->GetStaticMethodID(cls, "scilabLinesUpdate", "()V" ) ;
+    if (voidscilabLinesUpdateID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "scilabLinesUpdate");
+    }
 
-jmethodID voidsetPromptjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setPrompt", "(Ljava/lang/String;)V" ) ;
-if (voidsetPromptjstringjava_lang_StringID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "setPrompt");
+    curEnv->CallStaticVoidMethod(cls, voidscilabLinesUpdateID );
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-jstring promptToSet_ = curEnv->NewStringUTF( promptToSet );
-if (promptToSet != NULL && promptToSet_ == NULL)
+void CallScilabBridge::setPrompt (JavaVM * jvm_, char const* promptToSet)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-                         curEnv->CallStaticVoidMethod(cls, voidsetPromptjstringjava_lang_StringID ,promptToSet_);
-                        curEnv->DeleteLocalRef(promptToSet_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+    static jmethodID voidsetPromptjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setPrompt", "(Ljava/lang/String;)V" ) ;
+    if (voidsetPromptjstringjava_lang_StringID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "setPrompt");
+    }
 
-bool CallScilabBridge::isWaitingForInput (JavaVM * jvm_){
+    jstring promptToSet_ = curEnv->NewStringUTF( promptToSet );
+    if (promptToSet != NULL && promptToSet_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
 
-jmethodID jbooleanisWaitingForInputID = curEnv->GetStaticMethodID(cls, "isWaitingForInput", "()Z" ) ;
-if (jbooleanisWaitingForInputID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "isWaitingForInput");
+    curEnv->CallStaticVoidMethod(cls, voidsetPromptjstringjava_lang_StringID , promptToSet_);
+    curEnv->DeleteLocalRef(promptToSet_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-                        jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanisWaitingForInputID ));
-                        curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-return (res == JNI_TRUE);
+bool CallScilabBridge::isWaitingForInput (JavaVM * jvm_)
+{
+
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static jmethodID jbooleanisWaitingForInputID = curEnv->GetStaticMethodID(cls, "isWaitingForInput", "()Z" ) ;
+    if (jbooleanisWaitingForInputID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "isWaitingForInput");
+    }
+
+    jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanisWaitingForInputID ));
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return (res == JNI_TRUE);
 
 }
 
index 83b2b53..a36594d 100644 (file)
@@ -1,5 +1,5 @@
-/* Generated by GIWS (version 2.0.1) with command:
-giws --disable-return-size-array --output-dir D:\git\debug\similan\scilab\modules\console\src\jni\ --throws-exception-on-error --description-file CallScilabBridge.giws.xml 
+/* Generated by GIWS (version 2.0.2) with command:
+giws --disable-return-size-array --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/CallScilabBridge.giws.xml
 */
 /*
 
@@ -9,16 +9,16 @@ This software is a computer program whose purpose is to hide the complexity
 of accessing Java objects/methods from C++ code.
 
 This software is governed by the CeCILL-B license under French law and
-abiding by the rules of distribution of free software.  You can  use, 
+abiding by the rules of distribution of free software.  You can  use,
 modify and/ or redistribute the software under the terms of the CeCILL-B
 license as circulated by CEA, CNRS and INRIA at the following URL
-"http://www.cecill.info". 
+"http://www.cecill.info".
 
 As a counterpart to the access to the source code and  rights to copy,
 modify and redistribute granted by the license, users are provided only
 with a limited warranty  and the software's author,  the holder of the
 economic rights,  and the successive licensors  have only  limited
-liability. 
+liability.
 
 In this respect, the user's attention is drawn to the risks associated
 with loading,  using,  modifying and/or developing or reproducing the
@@ -27,9 +27,9 @@ that may mean  that it is complicated to manipulate,  and  that  also
 therefore means  that it is reserved for developers  and  experienced
 professionals having in-depth computer knowledge. Users are therefore
 encouraged to load and test the software's suitability as regards their
-requirements in conditions enabling the security of their systems and/or 
-data to be ensured and,  more generally, to use and operate it in the 
-same conditions as regards security. 
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
 
 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.
@@ -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,110 +69,134 @@ knowledge of the CeCILL-B license and that you accept its terms.
 # endif
 #endif
 
-namespace org_scilab_modules_gui_bridge {
-class GIWSEXPORT CallScilabBridge {
+namespace org_scilab_modules_gui_bridge
+{
+class GIWSEXPORT CallScilabBridge
+{
 
 private:
-JavaVM * jvm;
+    JavaVM * jvm;
 
 protected:
-jmethodID voiddisplayjstringjava_lang_StringID; // cache method id
-jmethodID jstringreadLineID; // cache method id
-jmethodID voidclearID; // cache method id
-jmethodID voidclearjintintID; // cache method id
-jmethodID jintgetCharWithoutOutputID; // cache method id
-jmethodID voidtoHomeID; // cache method id
-jmethodID voidscilabLinesUpdateID; // cache method id
-jmethodID voidsetPromptjstringjava_lang_StringID; // cache method id
-jmethodID jbooleanisWaitingForInputID; // cache method id
+    jmethodID voiddisplayjstringjava_lang_StringID; // cache method id
+    jmethodID jstringreadLineID; // cache method id
+    jmethodID voidclearID; // cache method id
+    jmethodID voidclearjintintID; // cache method id
+    jmethodID jintgetCharWithoutOutputID; // cache method id
+    jmethodID voidtoHomeID; // cache method id
+    jmethodID voidscilabLinesUpdateID; // cache method id
+    jmethodID voidsetPromptjstringjava_lang_StringID; // cache method id
+    jmethodID jbooleanisWaitingForInputID; // 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
-*/
-CallScilabBridge(JavaVM * jvm_);
+    // Constructor
+    /**
+    * Create a wrapping of the object from a JNIEnv.
+    * It will call the default constructor
+    * @param JEnv_ the Java Env
+    */
+    CallScilabBridge(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
+    */
+    CallScilabBridge(JavaVM * jvm_, jobject JObj);
+
+
+    /**
+    * This is a fake constructor to avoid the constructor
+    * chaining when dealing with extended giws classes
+    */
+#ifdef FAKEGIWSDATATYPE
+    CallScilabBridge(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
+#endif
 
-/**
-* 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
-*/
-CallScilabBridge(JavaVM * jvm_, jobject JObj);
+    // Destructor
+    ~CallScilabBridge();
 
+    // 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
-CallScilabBridge(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
-#endif
+    /**
+    * Exit monitor associated with the object.
+    * Equivalent of ending a "synchronized(obj)" scope.
+    */
+    void endSynchronize();
 
-// Destructor
-~CallScilabBridge();
+    // Methods
+    static void display(JavaVM * jvm_, char const* dataToDisplay);
 
-// Generic method
-// Synchronization methods
-/**
-* Enter monitor associated with the object.
-* Equivalent of creating a "synchronized(obj)" scope in Java.
-*/
-void synchronize();
+    static char* readLine(JavaVM * jvm_);
 
-/**
-* Exit monitor associated with the object.
-* Equivalent of ending a "synchronized(obj)" scope.
-*/
-void endSynchronize();
+    static void clear(JavaVM * jvm_);
+
+    static void clear(JavaVM * jvm_, int nbLines);
+
+    static int getCharWithoutOutput(JavaVM * jvm_);
+
+    static void toHome(JavaVM * jvm_);
+
+    static void scilabLinesUpdate(JavaVM * jvm_);
 
-// Methods
-static void display(JavaVM * jvm_, char const* dataToDisplay);
+    static void setPrompt(JavaVM * jvm_, char const* promptToSet);
 
-static char* readLine(JavaVM * jvm_);
+    static bool isWaitingForInput(JavaVM * jvm_);
 
-static void clear(JavaVM * jvm_);
 
-static void clear(JavaVM * jvm_, int nbLines);
+    /**
+    * Get class name to use for static methods
+    * @return class name to use for static methods
+    */
 
-static int getCharWithoutOutput(JavaVM * jvm_);
+    static const std::string className()
+    {
+        return "org/scilab/modules/gui/bridge/CallScilabBridge";
+    }
 
-static void toHome(JavaVM * jvm_);
 
-static void scilabLinesUpdate(JavaVM * jvm_);
+    /**
+    * Get class to use for static methods
+    * @return class to use for static methods
+    */
 
-static void setPrompt(JavaVM * jvm_, char const* promptToSet);
+    static jclass initClass(JNIEnv * curEnv)
+    {
+        static jclass cls = 0;
 
-static bool isWaitingForInput(JavaVM * jvm_);
+        if (cls == 0)
+        {
+            jclass _cls = curEnv->FindClass(className().c_str());
+            if (_cls)
+            {
+                cls = static_cast<jclass>(curEnv->NewGlobalRef(_cls));
+            }
+        }
 
+        return cls;
+    }
 
-                        /**
-                        * 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/gui/bridge/CallScilabBridge";
-                }
-                
 };
 
 
index f4d1c5f..2b06dcd 100644 (file)
@@ -1,6 +1,6 @@
 #include "ScilabClassLoader.hxx"
 /* Generated by GIWS (version 2.0.2) with command:
-giws -e -f ScilabObjects.giws.xml 
+giws --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/ScilabObjects.giws.xml
 */
 /*
 
@@ -36,146 +36,166 @@ 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 {
+namespace org_scilab_modules_external_objects_java
+{
+
+// Static declarations (if any)
 
-                // Static declarations (if any)
-                
 // Returns the current env
 
-JNIEnv * ScilabClassLoader::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 * ScilabClassLoader::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
 
-ScilabClassLoader::~ScilabClassLoader() {
-JNIEnv * curEnv = NULL;
-this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-curEnv->DeleteGlobalRef(this->instance);
-curEnv->DeleteGlobalRef(this->instanceClass);
+ScilabClassLoader::~ScilabClassLoader()
+{
+    JNIEnv * curEnv = NULL;
+    this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    curEnv->DeleteGlobalRef(this->instance);
+    curEnv->DeleteGlobalRef(this->instanceClass);
 }
 // Constructors
-ScilabClassLoader::ScilabClassLoader(JavaVM * jvm_) {
-jmethodID constructObject = NULL ;
-jobject localInstance ;
-jclass localClass ;
+ScilabClassLoader::ScilabClassLoader(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());
-}
+    localClass = curEnv->FindClass( this->className().c_str() ) ;
+    if (localClass == NULL)
+    {
+        throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+    }
 
-this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
 
-/* localClass is not needed anymore */
-curEnv->DeleteLocalRef(localClass);
+    /* localClass is not needed anymore */
+    curEnv->DeleteLocalRef(localClass);
 
-if (this->instanceClass == NULL) {
-throw GiwsException::JniObjectCreationException(curEnv, this->className());
-}
+    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());
-}
+    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);
+    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 */
-jintloadJavaClassjstringjava_lang_StringjbooleanbooleanID=NULL;
+    /* Methods ID set to NULL */
+    jintloadJavaClassjstringjava_lang_StringjbooleanbooleanID = NULL;
 
 
 }
 
-ScilabClassLoader::ScilabClassLoader(JavaVM * jvm_, jobject JObj) {
-        jvm=jvm_;
+ScilabClassLoader::ScilabClassLoader(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 */
-        jintloadJavaClassjstringjava_lang_StringjbooleanbooleanID=NULL;
+    this->instance = curEnv->NewGlobalRef(JObj) ;
+    if (this->instance == NULL)
+    {
+        throw GiwsException::JniObjectCreationException(curEnv, this->className());
+    }
+    /* Methods ID set to NULL */
+    jintloadJavaClassjstringjava_lang_StringjbooleanbooleanID = NULL;
 
 
 }
 
 // Generic methods
 
-void ScilabClassLoader::synchronize() {
-if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
-throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabClassLoader");
-}
+void ScilabClassLoader::synchronize()
+{
+    if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK)
+    {
+        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabClassLoader");
+    }
 }
 
-void ScilabClassLoader::endSynchronize() {
-if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
-throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabClassLoader");
-}
+void ScilabClassLoader::endSynchronize()
+{
+    if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK)
+    {
+        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabClassLoader");
+    }
 }
 // Method(s)
 
-int ScilabClassLoader::loadJavaClass (JavaVM * jvm_, char const* name, bool allowReload){
-
-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 jintloadJavaClassjstringjava_lang_StringjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "loadJavaClass", "(Ljava/lang/String;Z)I" ) ;
-if (jintloadJavaClassjstringjava_lang_StringjbooleanbooleanID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "loadJavaClass");
-}
-
-jstring name_ = curEnv->NewStringUTF( name );
-if (name != NULL && name_ == NULL)
+int ScilabClassLoader::loadJavaClass (JavaVM * jvm_, char const* name, bool allowReload)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
-
-jboolean allowReload_ = (static_cast<bool>(allowReload) ? JNI_TRUE : JNI_FALSE);
-
-                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintloadJavaClassjstringjava_lang_StringjbooleanbooleanID ,name_, allowReload_));
-                        curEnv->DeleteLocalRef(name_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-return res;
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static jmethodID jintloadJavaClassjstringjava_lang_StringjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "loadJavaClass", "(Ljava/lang/String;Z)I" ) ;
+    if (jintloadJavaClassjstringjava_lang_StringjbooleanbooleanID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "loadJavaClass");
+    }
+
+    jstring name_ = curEnv->NewStringUTF( name );
+    if (name != NULL && name_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+
+    jboolean allowReload_ = (static_cast<bool>(allowReload) ? JNI_TRUE : JNI_FALSE);
+
+    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintloadJavaClassjstringjava_lang_StringjbooleanbooleanID , name_, allowReload_));
+    curEnv->DeleteLocalRef(name_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
 }
 
index da66b31..9fe2afc 100644 (file)
@@ -1,5 +1,5 @@
 /* Generated by GIWS (version 2.0.2) with command:
-giws -e -f ScilabObjects.giws.xml 
+giws --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/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,86 +69,110 @@ knowledge of the CeCILL-B license and that you accept its terms.
 # endif
 #endif
 
-namespace org_scilab_modules_external_objects_java {
-class GIWSEXPORT ScilabClassLoader {
+namespace org_scilab_modules_external_objects_java
+{
+class GIWSEXPORT ScilabClassLoader
+{
 
 private:
-JavaVM * jvm;
+    JavaVM * jvm;
 
 protected:
-jmethodID jintloadJavaClassjstringjava_lang_StringjbooleanbooleanID; // cache method id
+    jmethodID jintloadJavaClassjstringjava_lang_StringjbooleanbooleanID; // 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
-*/
-ScilabClassLoader(JavaVM * jvm_);
+    // Constructor
+    /**
+    * Create a wrapping of the object from a JNIEnv.
+    * It will call the default constructor
+    * @param JEnv_ the Java Env
+    */
+    ScilabClassLoader(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
+    */
+    ScilabClassLoader(JavaVM * jvm_, jobject JObj);
+
+
+    /**
+    * This is a fake constructor to avoid the constructor
+    * chaining when dealing with extended giws classes
+    */
+#ifdef FAKEGIWSDATATYPE
+    ScilabClassLoader(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
+#endif
 
-/**
-* 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
-*/
-ScilabClassLoader(JavaVM * jvm_, jobject JObj);
+    // Destructor
+    ~ScilabClassLoader();
 
+    // 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
-ScilabClassLoader(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
-#endif
+    /**
+    * Exit monitor associated with the object.
+    * Equivalent of ending a "synchronized(obj)" scope.
+    */
+    void endSynchronize();
 
-// Destructor
-~ScilabClassLoader();
+    // Methods
+    static int loadJavaClass(JavaVM * jvm_, char const* name, bool allowReload);
 
-// 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 loadJavaClass(JavaVM * jvm_, char const* name, bool allowReload);
-
-
-                        /**
-                        * 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/ScilabClassLoader";
-                }
-                
+    /**
+    * 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/ScilabClassLoader";
+    }
+
+
+    /**
+    * Get class to use for static methods
+    * @return class to use for static methods
+    */
+
+    static jclass initClass(JNIEnv * curEnv)
+    {
+        static jclass cls = 0;
+
+        if (cls == 0)
+        {
+            jclass _cls = curEnv->FindClass(className().c_str());
+            if (_cls)
+            {
+                cls = static_cast<jclass>(curEnv->NewGlobalRef(_cls));
+            }
+        }
+
+        return cls;
+    }
+
 };
 
 
index 1cb1564..08cfc5c 100644 (file)
@@ -1,6 +1,6 @@
 #include "ScilabJarCreator.hxx"
 /* Generated by GIWS (version 2.0.2) with command:
-giws -e -f ScilabObjects.giws.xml 
+giws --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/ScilabObjects.giws.xml
 */
 /*
 
@@ -36,186 +36,207 @@ 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 {
+namespace org_scilab_modules_external_objects_java
+{
+
+// Static declarations (if any)
 
-                // 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);
-curEnv->DeleteGlobalRef(this->instance);
-curEnv->DeleteGlobalRef(this->instanceClass);
-curEnv->DeleteGlobalRef(this->stringArrayClass);}
-// Constructors
-ScilabJarCreator::ScilabJarCreator(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());
+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 ;
 
+    const std::string construct = "<init>";
+    const std::string param = "()V";
+    jvm = jvm_;
 
-constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
-if(constructObject == NULL){
-throw GiwsException::JniObjectCreationException(curEnv, this->className());
-}
+    JNIEnv * curEnv = getCurrentEnv();
 
-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);
+    localClass = curEnv->FindClass( this->className().c_str() ) ;
+    if (localClass == NULL)
+    {
+        throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+    }
 
-                /* Methods ID set to NULL */
-jintcreateJarArchivejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID=NULL;
+    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());
+    }
 
-ScilabJarCreator::ScilabJarCreator(JavaVM * jvm_, jobject JObj) {
-        jvm=jvm_;
 
-        JNIEnv * curEnv = getCurrentEnv();
+    constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
+    if (constructObject == NULL)
+    {
+        throw GiwsException::JniObjectCreationException(curEnv, this->className());
+    }
 
-jclass localClass = curEnv->GetObjectClass(JObj);
-        this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
-        curEnv->DeleteLocalRef(localClass);
+    localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
+    if (localInstance == NULL)
+    {
+        throw GiwsException::JniObjectCreationException(curEnv, this->className());
+    }
 
-        if (this->instanceClass == 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);
 
-        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;
+    /* Methods ID set to NULL */
+    jintcreateJarArchivejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID = NULL;
 
 
 }
 
-// Generic methods
+ScilabJarCreator::ScilabJarCreator(JavaVM * jvm_, jobject JObj)
+{
+    jvm = jvm_;
 
-void ScilabJarCreator::synchronize() {
-if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
-throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJarCreator");
-}
-}
+    JNIEnv * curEnv = getCurrentEnv();
 
-void ScilabJarCreator::endSynchronize() {
-if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
-throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJarCreator");
-}
-}
-// Method(s)
+    jclass localClass = curEnv->GetObjectClass(JObj);
+    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+    curEnv->DeleteLocalRef(localClass);
 
-int ScilabJarCreator::createJarArchive (JavaVM * jvm_, char const* jarFilePath, char const* const* filePaths, int filePathsSize, char const* filesRootPath, char const* manifestFilePath, bool keepAbsolutePaths){
+    if (this->instanceClass == NULL)
+    {
+        throw GiwsException::JniObjectCreationException(curEnv, this->className());
+    }
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
-if ( cls == NULL) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
+    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;
 
-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);
-}
+// Generic methods
 
-// 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)
+void ScilabJarCreator::synchronize()
 {
-throw GiwsException::JniBadAllocException(curEnv);
+    if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK)
+    {
+        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJarCreator");
+    }
 }
 
-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)
+void ScilabJarCreator::endSynchronize()
 {
-throw GiwsException::JniBadAllocException(curEnv);
+    if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK)
+    {
+        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJarCreator");
+    }
 }
+// Method(s)
 
-
-jstring manifestFilePath_ = curEnv->NewStringUTF( manifestFilePath );
-if (manifestFilePath != NULL && manifestFilePath_ == NULL)
+int ScilabJarCreator::createJarArchive (JavaVM * jvm_, char const* jarFilePath, char const* const* filePaths, int filePathsSize, char const* filesRootPath, char const* manifestFilePath, bool keepAbsolutePaths)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
-
 
-jboolean keepAbsolutePaths_ = (static_cast<bool>(keepAbsolutePaths) ? JNI_TRUE : JNI_FALSE);
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static 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);
+        }
 
-                        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;
+        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);
+    }
+
+
+    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_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
 }
 
index a29b893..05d90d0 100644 (file)
@@ -1,5 +1,5 @@
 /* Generated by GIWS (version 2.0.2) with command:
-giws -e -f ScilabObjects.giws.xml 
+giws --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/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,87 +69,111 @@ knowledge of the CeCILL-B license and that you accept its terms.
 # 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_);
+    // 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
 
-/**
-* 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);
+    // Destructor
+    ~ScilabJarCreator();
 
+    // 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
-ScilabJarCreator(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
-#endif
+    /**
+    * Exit monitor associated with the object.
+    * Equivalent of ending a "synchronized(obj)" scope.
+    */
+    void endSynchronize();
 
-// Destructor
-~ScilabJarCreator();
+    // Methods
+    static int createJarArchive(JavaVM * jvm_, char const* jarFilePath, char const* const* filePaths, int filePathsSize, char const* filesRootPath, char const* manifestFilePath, bool keepAbsolutePaths);
 
-// 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";
-                }
-                
+    /**
+    * 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";
+    }
+
+
+    /**
+    * Get class to use for static methods
+    * @return class to use for static methods
+    */
+
+    static jclass initClass(JNIEnv * curEnv)
+    {
+        static jclass cls = 0;
+
+        if (cls == 0)
+        {
+            jclass _cls = curEnv->FindClass(className().c_str());
+            if (_cls)
+            {
+                cls = static_cast<jclass>(curEnv->NewGlobalRef(_cls));
+            }
+        }
+
+        return cls;
+    }
+
 };
 
 
index 794212a..9dd0e61 100644 (file)
@@ -1,6 +1,6 @@
 #include "ScilabJavaArray.hxx"
 /* Generated by GIWS (version 2.0.2) with command:
-giws -e -f ScilabObjects.giws.xml 
+giws --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/ScilabObjects.giws.xml
 */
 /*
 
@@ -36,156 +36,176 @@ 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 {
+namespace org_scilab_modules_external_objects_java
+{
+
+// Static declarations (if any)
 
-                // Static declarations (if any)
-                
 // Returns the current env
 
-JNIEnv * ScilabJavaArray::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 * ScilabJavaArray::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
 
-ScilabJavaArray::~ScilabJavaArray() {
-JNIEnv * curEnv = NULL;
-this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-curEnv->DeleteGlobalRef(this->instance);
-curEnv->DeleteGlobalRef(this->instanceClass);
+ScilabJavaArray::~ScilabJavaArray()
+{
+    JNIEnv * curEnv = NULL;
+    this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    curEnv->DeleteGlobalRef(this->instance);
+    curEnv->DeleteGlobalRef(this->instanceClass);
 }
 // Constructors
-ScilabJavaArray::ScilabJavaArray(JavaVM * jvm_) {
-jmethodID constructObject = NULL ;
-jobject localInstance ;
-jclass localClass ;
+ScilabJavaArray::ScilabJavaArray(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());
-}
+    localClass = curEnv->FindClass( this->className().c_str() ) ;
+    if (localClass == NULL)
+    {
+        throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+    }
 
-this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
 
-/* localClass is not needed anymore */
-curEnv->DeleteLocalRef(localClass);
+    /* localClass is not needed anymore */
+    curEnv->DeleteLocalRef(localClass);
 
-if (this->instanceClass == NULL) {
-throw GiwsException::JniObjectCreationException(curEnv, this->className());
-}
+    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());
-}
+    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);
+    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 */
-jintnewInstancejstringjava_lang_StringjintArray_intintID=NULL;
+    /* Methods ID set to NULL */
+    jintnewInstancejstringjava_lang_StringjintArray_intintID = NULL;
 
 
 }
 
-ScilabJavaArray::ScilabJavaArray(JavaVM * jvm_, jobject JObj) {
-        jvm=jvm_;
+ScilabJavaArray::ScilabJavaArray(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 */
-        jintnewInstancejstringjava_lang_StringjintArray_intintID=NULL;
+    this->instance = curEnv->NewGlobalRef(JObj) ;
+    if (this->instance == NULL)
+    {
+        throw GiwsException::JniObjectCreationException(curEnv, this->className());
+    }
+    /* Methods ID set to NULL */
+    jintnewInstancejstringjava_lang_StringjintArray_intintID = NULL;
 
 
 }
 
 // Generic methods
 
-void ScilabJavaArray::synchronize() {
-if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
-throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaArray");
-}
-}
-
-void ScilabJavaArray::endSynchronize() {
-if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
-throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaArray");
-}
-}
-// Method(s)
-
-int ScilabJavaArray::newInstance (JavaVM * jvm_, char const* name, 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 jintnewInstancejstringjava_lang_StringjintArray_intintID = curEnv->GetStaticMethodID(cls, "newInstance", "(Ljava/lang/String;[I)I" ) ;
-if (jintnewInstancejstringjava_lang_StringjintArray_intintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "newInstance");
-}
-
-jstring name_ = curEnv->NewStringUTF( name );
-if (name != NULL && name_ == NULL)
+void ScilabJavaArray::synchronize()
 {
-throw GiwsException::JniBadAllocException(curEnv);
+    if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK)
+    {
+        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaArray");
+    }
 }
 
-
-jintArray args_ = curEnv->NewIntArray( argsSize ) ;
-
-if (args_ == NULL)
+void ScilabJavaArray::endSynchronize()
 {
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
+    if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK)
+    {
+        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaArray");
+    }
 }
+// Method(s)
 
-curEnv->SetIntArrayRegion( args_, 0, argsSize, (jint*)(args) ) ;
-
+int ScilabJavaArray::newInstance (JavaVM * jvm_, char const* name, int const* args, int argsSize)
+{
 
-                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewInstancejstringjava_lang_StringjintArray_intintID ,name_, args_));
-                        curEnv->DeleteLocalRef(name_);
-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 = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static jmethodID jintnewInstancejstringjava_lang_StringjintArray_intintID = curEnv->GetStaticMethodID(cls, "newInstance", "(Ljava/lang/String;[I)I" ) ;
+    if (jintnewInstancejstringjava_lang_StringjintArray_intintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "newInstance");
+    }
+
+    jstring name_ = curEnv->NewStringUTF( name );
+    if (name != NULL && name_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+
+    jintArray args_ = curEnv->NewIntArray( argsSize ) ;
+
+    if (args_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+    curEnv->SetIntArrayRegion( args_, 0, argsSize, (jint*)(args) ) ;
+
+
+    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewInstancejstringjava_lang_StringjintArray_intintID , name_, args_));
+    curEnv->DeleteLocalRef(name_);
+    curEnv->DeleteLocalRef(args_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
 }
 
index 0a865a2..053ef3c 100644 (file)
@@ -1,5 +1,5 @@
 /* Generated by GIWS (version 2.0.2) with command:
-giws -e -f ScilabObjects.giws.xml 
+giws --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/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,86 +69,110 @@ knowledge of the CeCILL-B license and that you accept its terms.
 # endif
 #endif
 
-namespace org_scilab_modules_external_objects_java {
-class GIWSEXPORT ScilabJavaArray {
+namespace org_scilab_modules_external_objects_java
+{
+class GIWSEXPORT ScilabJavaArray
+{
 
 private:
-JavaVM * jvm;
+    JavaVM * jvm;
 
 protected:
-jmethodID jintnewInstancejstringjava_lang_StringjintArray_intintID; // cache method id
+    jmethodID jintnewInstancejstringjava_lang_StringjintArray_intintID; // 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
-*/
-ScilabJavaArray(JavaVM * jvm_);
+    // Constructor
+    /**
+    * Create a wrapping of the object from a JNIEnv.
+    * It will call the default constructor
+    * @param JEnv_ the Java Env
+    */
+    ScilabJavaArray(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
+    */
+    ScilabJavaArray(JavaVM * jvm_, jobject JObj);
+
+
+    /**
+    * This is a fake constructor to avoid the constructor
+    * chaining when dealing with extended giws classes
+    */
+#ifdef FAKEGIWSDATATYPE
+    ScilabJavaArray(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
+#endif
 
-/**
-* 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
-*/
-ScilabJavaArray(JavaVM * jvm_, jobject JObj);
+    // Destructor
+    ~ScilabJavaArray();
 
+    // 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
-ScilabJavaArray(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
-#endif
+    /**
+    * Exit monitor associated with the object.
+    * Equivalent of ending a "synchronized(obj)" scope.
+    */
+    void endSynchronize();
 
-// Destructor
-~ScilabJavaArray();
+    // Methods
+    static int newInstance(JavaVM * jvm_, char const* name, 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();
 
-/**
-* Exit monitor associated with the object.
-* Equivalent of ending a "synchronized(obj)" scope.
-*/
-void endSynchronize();
-
-// Methods
-static int newInstance(JavaVM * jvm_, char const* name, int const* args, int argsSize);
-
-
-                        /**
-                        * 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/ScilabJavaArray";
-                }
-                
+    /**
+    * 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/ScilabJavaArray";
+    }
+
+
+    /**
+    * Get class to use for static methods
+    * @return class to use for static methods
+    */
+
+    static jclass initClass(JNIEnv * curEnv)
+    {
+        static jclass cls = 0;
+
+        if (cls == 0)
+        {
+            jclass _cls = curEnv->FindClass(className().c_str());
+            if (_cls)
+            {
+                cls = static_cast<jclass>(curEnv->NewGlobalRef(_cls));
+            }
+        }
+
+        return cls;
+    }
+
 };
 
 
index 263eac0..fca8af2 100644 (file)
@@ -1,6 +1,6 @@
 #include "ScilabJavaClass.hxx"
 /* Generated by GIWS (version 2.0.2) with command:
-giws -e -f ScilabObjects.giws.xml 
+giws --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/ScilabObjects.giws.xml
 */
 /*
 
@@ -36,148 +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 {
+namespace org_scilab_modules_external_objects_java
+{
+
+// Static declarations (if any)
 
-                // Static declarations (if any)
-                
 // Returns the current env
 
-JNIEnv * ScilabJavaClass::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 * ScilabJavaClass::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
 
-ScilabJavaClass::~ScilabJavaClass() {
-JNIEnv * curEnv = NULL;
-this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-curEnv->DeleteGlobalRef(this->instance);
-curEnv->DeleteGlobalRef(this->instanceClass);
+ScilabJavaClass::~ScilabJavaClass()
+{
+    JNIEnv * curEnv = NULL;
+    this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    curEnv->DeleteGlobalRef(this->instance);
+    curEnv->DeleteGlobalRef(this->instanceClass);
 }
 // Constructors
-ScilabJavaClass::ScilabJavaClass(JavaVM * jvm_) {
-jmethodID constructObject = NULL ;
-jobject localInstance ;
-jclass localClass ;
+ScilabJavaClass::ScilabJavaClass(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());
-}
+    localClass = curEnv->FindClass( this->className().c_str() ) ;
+    if (localClass == NULL)
+    {
+        throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+    }
 
-this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
 
-/* localClass is not needed anymore */
-curEnv->DeleteLocalRef(localClass);
+    /* localClass is not needed anymore */
+    curEnv->DeleteLocalRef(localClass);
 
-if (this->instanceClass == NULL) {
-throw GiwsException::JniObjectCreationException(curEnv, this->className());
-}
+    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());
-}
+    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);
+    localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
+    if (localInstance == NULL)
+    {
+        throw GiwsException::JniObjectCreationException(curEnv, this->className());
+    }
 
-                /* Methods ID set to NULL */
-jintnewInstancejintintjintArray_intintID=NULL;
+    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 */
+    jintnewInstancejintintjintArray_intintID = NULL;
 
 
 }
 
-ScilabJavaClass::ScilabJavaClass(JavaVM * jvm_, jobject JObj) {
-        jvm=jvm_;
+ScilabJavaClass::ScilabJavaClass(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 */
-        jintnewInstancejintintjintArray_intintID=NULL;
+    this->instance = curEnv->NewGlobalRef(JObj) ;
+    if (this->instance == NULL)
+    {
+        throw GiwsException::JniObjectCreationException(curEnv, this->className());
+    }
+    /* Methods ID set to NULL */
+    jintnewInstancejintintjintArray_intintID = NULL;
 
 
 }
 
 // Generic methods
 
-void ScilabJavaClass::synchronize() {
-if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
-throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaClass");
-}
+void ScilabJavaClass::synchronize()
+{
+    if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK)
+    {
+        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaClass");
+    }
 }
 
-void ScilabJavaClass::endSynchronize() {
-if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
-throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaClass");
-}
+void ScilabJavaClass::endSynchronize()
+{
+    if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK)
+    {
+        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaClass");
+    }
 }
 // Method(s)
 
-int ScilabJavaClass::newInstance (JavaVM * jvm_, int id, 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 jintnewInstancejintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "newInstance", "(I[I)I" ) ;
-if (jintnewInstancejintintjintArray_intintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "newInstance");
-}
-
-jintArray args_ = curEnv->NewIntArray( argsSize ) ;
-
-if (args_ == NULL)
+int ScilabJavaClass::newInstance (JavaVM * jvm_, int id, int const* args, int argsSize)
 {
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
-curEnv->SetIntArrayRegion( args_, 0, argsSize, (jint*)(args) ) ;
-
-
-                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewInstancejintintjintArray_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 = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static jmethodID jintnewInstancejintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "newInstance", "(I[I)I" ) ;
+    if (jintnewInstancejintintjintArray_intintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "newInstance");
+    }
+
+    jintArray args_ = curEnv->NewIntArray( argsSize ) ;
+
+    if (args_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+    curEnv->SetIntArrayRegion( args_, 0, argsSize, (jint*)(args) ) ;
+
+
+    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintnewInstancejintintjintArray_intintID , id, args_));
+    curEnv->DeleteLocalRef(args_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
 }
 
index 8062c21..a2003c1 100644 (file)
@@ -1,5 +1,5 @@
 /* Generated by GIWS (version 2.0.2) with command:
-giws -e -f ScilabObjects.giws.xml 
+giws --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/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,86 +69,110 @@ knowledge of the CeCILL-B license and that you accept its terms.
 # endif
 #endif
 
-namespace org_scilab_modules_external_objects_java {
-class GIWSEXPORT ScilabJavaClass {
+namespace org_scilab_modules_external_objects_java
+{
+class GIWSEXPORT ScilabJavaClass
+{
 
 private:
-JavaVM * jvm;
+    JavaVM * jvm;
 
 protected:
-jmethodID jintnewInstancejintintjintArray_intintID; // cache method id
+    jmethodID jintnewInstancejintintjintArray_intintID; // 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
-*/
-ScilabJavaClass(JavaVM * jvm_);
+    // Constructor
+    /**
+    * Create a wrapping of the object from a JNIEnv.
+    * It will call the default constructor
+    * @param JEnv_ the Java Env
+    */
+    ScilabJavaClass(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
+    */
+    ScilabJavaClass(JavaVM * jvm_, jobject JObj);
+
+
+    /**
+    * This is a fake constructor to avoid the constructor
+    * chaining when dealing with extended giws classes
+    */
+#ifdef FAKEGIWSDATATYPE
+    ScilabJavaClass(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
+#endif
 
-/**
-* 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
-*/
-ScilabJavaClass(JavaVM * jvm_, jobject JObj);
+    // Destructor
+    ~ScilabJavaClass();
 
+    // 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
-ScilabJavaClass(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
-#endif
+    /**
+    * Exit monitor associated with the object.
+    * Equivalent of ending a "synchronized(obj)" scope.
+    */
+    void endSynchronize();
 
-// Destructor
-~ScilabJavaClass();
+    // Methods
+    static int newInstance(JavaVM * jvm_, int id, 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();
 
-/**
-* Exit monitor associated with the object.
-* Equivalent of ending a "synchronized(obj)" scope.
-*/
-void endSynchronize();
-
-// Methods
-static int newInstance(JavaVM * jvm_, int id, int const* args, int argsSize);
-
-
-                        /**
-                        * 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/ScilabJavaClass";
-                }
-                
+    /**
+    * 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/ScilabJavaClass";
+    }
+
+
+    /**
+    * Get class to use for static methods
+    * @return class to use for static methods
+    */
+
+    static jclass initClass(JNIEnv * curEnv)
+    {
+        static jclass cls = 0;
+
+        if (cls == 0)
+        {
+            jclass _cls = curEnv->FindClass(className().c_str());
+            if (_cls)
+            {
+                cls = static_cast<jclass>(curEnv->NewGlobalRef(_cls));
+            }
+        }
+
+        return cls;
+    }
+
 };
 
 
index c6ac74e..6bc9a17 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 --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/ScilabObjects.giws.xml
 */
 /*
 
@@ -36,168 +36,189 @@ 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 {
+namespace org_scilab_modules_external_objects_java
+{
+
+// Static declarations (if any)
 
-                // 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());
-}
+    localClass = curEnv->FindClass( this->className().c_str() ) ;
+    if (localClass == NULL)
+    {
+        throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+    }
 
-this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
 
-/* localClass is not needed anymore */
-curEnv->DeleteLocalRef(localClass);
+    /* localClass is not needed anymore */
+    curEnv->DeleteLocalRef(localClass);
 
-if (this->instanceClass == NULL) {
-throw GiwsException::JniObjectCreationException(curEnv, this->className());
-}
+    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());
-}
+    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);
+    localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
+    if (localInstance == 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(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;
 
 
 }
 
-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() {
-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)
+void ScilabJavaCompiler::synchronize()
 {
-throw GiwsException::JniBadAllocException(curEnv);
+    if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK)
+    {
+        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaCompiler");
+    }
 }
 
-jclass stringArrayClass = curEnv->FindClass("java/lang/String");
-
-// create java array of strings.
-jobjectArray code_ = curEnv->NewObjectArray( codeSize, stringArrayClass, NULL);
-if (code_ == NULL)
+void ScilabJavaCompiler::endSynchronize()
 {
-throw GiwsException::JniBadAllocException(curEnv);
+    if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK)
+    {
+        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaCompiler");
+    }
 }
+// Method(s)
 
-// 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)
+int ScilabJavaCompiler::compileCode (JavaVM * jvm_, char const* classname, char const* const* code, int codeSize)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
-curEnv->SetObjectArrayElement( code_, i, TempString);
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static 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);
+        }
 
-// 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;
+        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_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
 }
 
index 93ad8ae..8c972a2 100644 (file)
@@ -1,5 +1,5 @@
 /* Generated by GIWS (version 2.0.2) with command:
-giws -e -f ScilabObjects.giws.xml 
+giws --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/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,87 +69,111 @@ knowledge of the CeCILL-B license and that you accept its terms.
 # endif
 #endif
 
-namespace org_scilab_modules_external_objects_java {
-class GIWSEXPORT ScilabJavaCompiler {
+namespace org_scilab_modules_external_objects_java
+{
+class GIWSEXPORT ScilabJavaCompiler
+{
 
 private:
-JavaVM * jvm;
+    JavaVM * jvm;
 
 protected:
-jmethodID jintcompileCodejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID; // cache method id
-jclass stringArrayClass;
+    jmethodID jintcompileCodejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID; // 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
-*/
-ScilabJavaCompiler(JavaVM * jvm_);
+    // Constructor
+    /**
+    * Create a wrapping of the object from a JNIEnv.
+    * It will call the default constructor
+    * @param JEnv_ the Java Env
+    */
+    ScilabJavaCompiler(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
+    */
+    ScilabJavaCompiler(JavaVM * jvm_, jobject JObj);
+
+
+    /**
+    * This is a fake constructor to avoid the constructor
+    * chaining when dealing with extended giws classes
+    */
+#ifdef FAKEGIWSDATATYPE
+    ScilabJavaCompiler(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
+#endif
 
-/**
-* 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
-*/
-ScilabJavaCompiler(JavaVM * jvm_, jobject JObj);
+    // Destructor
+    ~ScilabJavaCompiler();
 
+    // 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
-ScilabJavaCompiler(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
-#endif
+    /**
+    * Exit monitor associated with the object.
+    * Equivalent of ending a "synchronized(obj)" scope.
+    */
+    void endSynchronize();
 
-// Destructor
-~ScilabJavaCompiler();
+    // Methods
+    static int compileCode(JavaVM * jvm_, char const* classname, char const* const* code, int codeSize);
 
-// 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 compileCode(JavaVM * jvm_, char const* classname, char const* const* code, int codeSize);
-
-
-                        /**
-                        * 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/ScilabJavaCompiler";
-                }
-                
+    /**
+    * 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/ScilabJavaCompiler";
+    }
+
+
+    /**
+    * Get class to use for static methods
+    * @return class to use for static methods
+    */
+
+    static jclass initClass(JNIEnv * curEnv)
+    {
+        static jclass cls = 0;
+
+        if (cls == 0)
+        {
+            jclass _cls = curEnv->FindClass(className().c_str());
+            if (_cls)
+            {
+                cls = static_cast<jclass>(curEnv->NewGlobalRef(_cls));
+            }
+        }
+
+        return cls;
+    }
+
 };
 
 
index 4467fdb..b26a45b 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 --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/ScilabObjects.giws.xml
 */
 /*
 
@@ -36,2013 +36,2233 @@ 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 {
+namespace org_scilab_modules_external_objects_java
+{
+
+// Static declarations (if any)
 
-                // 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);}
-// 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()
+{
+    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(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;
+// 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;
 
 
 }
 
 // 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){
-
-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)
+int ScilabJavaObject::invoke (JavaVM * jvm_, int id, char const* methodName, int const* args, int argsSize)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-jintArray args_ = curEnv->NewIntArray( argsSize ) ;
+    static 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");
+    }
 
-if (args_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    jstring methodName_ = curEnv->NewStringUTF( methodName );
+    if (methodName != NULL && methodName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-curEnv->SetIntArrayRegion( args_, 0, argsSize, (jint*)(args) ) ;
 
+    jintArray args_ = curEnv->NewIntArray( 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;
+    if (args_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-}
+    curEnv->SetIntArrayRegion( args_, 0, argsSize, (jint*)(args) ) ;
 
-int ScilabJavaObject::extract (JavaVM * jvm_, int id, 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);
-}
+    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintinvokejintintjstringjava_lang_StringjintArray_intintID , id, methodName_, args_));
+    curEnv->DeleteLocalRef(methodName_);
+    curEnv->DeleteLocalRef(args_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-jmethodID jintextractjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "extract", "(I[I)I" ) ;
-if (jintextractjintintjintArray_intintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "extract");
 }
 
-jintArray args_ = curEnv->NewIntArray( argsSize ) ;
-
-if (args_ == NULL)
+int ScilabJavaObject::extract (JavaVM * jvm_, int id, int const* args, int argsSize)
 {
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
-curEnv->SetIntArrayRegion( args_, 0, argsSize, (jint*)(args) ) ;
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
+    static jmethodID jintextractjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "extract", "(I[I)I" ) ;
+    if (jintextractjintintjintArray_intintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "extract");
+    }
 
-                        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;
-
-}
+    jintArray args_ = curEnv->NewIntArray( argsSize ) ;
 
-void ScilabJavaObject::insert (JavaVM * jvm_, int id, int const* keys, int keysSize, int value){
+    if (args_ == 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( args_, 0, argsSize, (jint*)(args) ) ;
 
-jmethodID voidinsertjintintjintArray_intintjintintID = curEnv->GetStaticMethodID(cls, "insert", "(I[II)V" ) ;
-if (voidinsertjintintjintArray_intintjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "insert");
-}
 
-jintArray keys_ = curEnv->NewIntArray( keysSize ) ;
+    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintextractjintintjintArray_intintID , id, args_));
+    curEnv->DeleteLocalRef(args_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-if (keys_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
 }
 
-curEnv->SetIntArrayRegion( keys_, 0, keysSize, (jint*)(keys) ) ;
-
+void ScilabJavaObject::insert (JavaVM * jvm_, int id, int const* keys, int keysSize, int value)
+{
 
-                         curEnv->CallStaticVoidMethod(cls, voidinsertjintintjintArray_intintjintintID ,id, keys_, value);
-                        curEnv->DeleteLocalRef(keys_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-char** ScilabJavaObject::getInfos (JavaVM * jvm_, int *lenRow){
+    static jmethodID voidinsertjintintjintArray_intintjintintID = curEnv->GetStaticMethodID(cls, "insert", "(I[II)V" ) ;
+    if (voidinsertjintintjintArray_intintjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "insert");
+    }
 
-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 keys_ = curEnv->NewIntArray( keysSize ) ;
 
-jmethodID jobjectArray_getInfosID = curEnv->GetStaticMethodID(cls, "getInfos", "()[Ljava/lang/String;" ) ;
-if (jobjectArray_getInfosID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "getInfos");
-}
+    if (keys_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(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;
-}
-}
+    curEnv->SetIntArrayRegion( keys_, 0, keysSize, (jint*)(keys) ) ;
 
-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);
+    curEnv->CallStaticVoidMethod(cls, voidinsertjintintjintArray_intintjintintID , id, keys_, value);
+    curEnv->DeleteLocalRef(keys_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-jmethodID voidinitScilabJavaObjectID = curEnv->GetStaticMethodID(cls, "initScilabJavaObject", "()V" ) ;
-if (voidinitScilabJavaObjectID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "initScilabJavaObject");
-}
+char** ScilabJavaObject::getInfos (JavaVM * jvm_, int *lenRow)
+{
 
-                         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 = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static 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);
+        }
+        if (curEnv->ExceptionCheck())
+        {
+            delete[] arrayOfString;
+            throw GiwsException::JniCallMethodException(curEnv);
+        }
+        curEnv->DeleteLocalRef(res);
+        return arrayOfString;
+    }
+    else
+    {
+        curEnv->DeleteLocalRef(res);
+        return NULL;
+    }
 }
 
-void ScilabJavaObject::garbageCollect (JavaVM * jvm_){
+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);
-}
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-jmethodID voidgarbageCollectID = curEnv->GetStaticMethodID(cls, "garbageCollect", "()V" ) ;
-if (voidgarbageCollectID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "garbageCollect");
-}
+    static jmethodID voidinitScilabJavaObjectID = curEnv->GetStaticMethodID(cls, "initScilabJavaObject", "()V" ) ;
+    if (voidinitScilabJavaObjectID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "initScilabJavaObject");
+    }
 
-                         curEnv->CallStaticVoidMethod(cls, voidgarbageCollectID );
-                        curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
+    curEnv->CallStaticVoidMethod(cls, voidinitScilabJavaObjectID );
+    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);
-}
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    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");
-}
+    static jmethodID voidgarbageCollectID = curEnv->GetStaticMethodID(cls, "garbageCollect", "()V" ) ;
+    if (voidgarbageCollectID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "garbageCollect");
+    }
 
-                        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;
-}
+    curEnv->CallStaticVoidMethod(cls, voidgarbageCollectID );
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-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);
-}
+char* ScilabJavaObject::getRepresentation (JavaVM * jvm_, int id)
+{
 
-jmethodID jbooleanisValidJavaObjectjintintID = curEnv->GetStaticMethodID(cls, "isValidJavaObject", "(I)Z" ) ;
-if (jbooleanisValidJavaObjectjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "isValidJavaObject");
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static 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);
+        if (curEnv->ExceptionCheck())
+        {
+            delete[] myStringBuffer;
+            throw GiwsException::JniCallMethodException(curEnv);
+        }
+        return myStringBuffer;
+    }
+    else
+    {
+        curEnv->DeleteLocalRef(res);
+        return NULL;
+    }
 }
 
-                        jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanisValidJavaObjectjintintID ,id));
-                        curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-return (res == JNI_TRUE);
+bool ScilabJavaObject::isValidJavaObject (JavaVM * jvm_, int id)
+{
 
-}
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-void ScilabJavaObject::enableTrace (JavaVM * jvm_, char const* filename){
+    static jmethodID jbooleanisValidJavaObjectjintintID = curEnv->GetStaticMethodID(cls, "isValidJavaObject", "(I)Z" ) ;
+    if (jbooleanisValidJavaObjectjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "isValidJavaObject");
+    }
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
-if ( cls == NULL) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
+    jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanisValidJavaObjectjintintID , id));
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return (res == JNI_TRUE);
 
-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)
+void ScilabJavaObject::enableTrace (JavaVM * jvm_, char const* filename)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-                         curEnv->CallStaticVoidMethod(cls, voidenableTracejstringjava_lang_StringID ,filename_);
-                        curEnv->DeleteLocalRef(filename_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+    static jmethodID voidenableTracejstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "enableTrace", "(Ljava/lang/String;)V" ) ;
+    if (voidenableTracejstringjava_lang_StringID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "enableTrace");
+    }
 
-void ScilabJavaObject::disableTrace (JavaVM * jvm_){
+    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 voiddisableTraceID = curEnv->GetStaticMethodID(cls, "disableTrace", "()V" ) ;
-if (voiddisableTraceID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "disableTrace");
+    curEnv->CallStaticVoidMethod(cls, voidenableTracejstringjava_lang_StringID , filename_);
+    curEnv->DeleteLocalRef(filename_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-                         curEnv->CallStaticVoidMethod(cls, voiddisableTraceID );
-                        curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+void ScilabJavaObject::disableTrace (JavaVM * jvm_)
+{
 
-void ScilabJavaObject::writeLog (JavaVM * jvm_, char const* s){
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    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);
-}
+    static jmethodID voiddisableTraceID = curEnv->GetStaticMethodID(cls, "disableTrace", "()V" ) ;
+    if (voiddisableTraceID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "disableTrace");
+    }
 
-jmethodID voidwriteLogjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "writeLog", "(Ljava/lang/String;)V" ) ;
-if (voidwriteLogjstringjava_lang_StringID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "writeLog");
+    curEnv->CallStaticVoidMethod(cls, voiddisableTraceID );
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-jstring s_ = curEnv->NewStringUTF( s );
-if (s != NULL && s_ == NULL)
+void ScilabJavaObject::writeLog (JavaVM * jvm_, char const* s)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-                         curEnv->CallStaticVoidMethod(cls, voidwriteLogjstringjava_lang_StringID ,s_);
-                        curEnv->DeleteLocalRef(s_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+    static jmethodID voidwriteLogjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "writeLog", "(Ljava/lang/String;)V" ) ;
+    if (voidwriteLogjstringjava_lang_StringID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "writeLog");
+    }
 
-void ScilabJavaObject::setField (JavaVM * jvm_, int id, char const* fieldName, int idarg){
+    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 voidsetFieldjintintjstringjava_lang_StringjintintID = curEnv->GetStaticMethodID(cls, "setField", "(ILjava/lang/String;I)V" ) ;
-if (voidsetFieldjintintjstringjava_lang_StringjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "setField");
+    curEnv->CallStaticVoidMethod(cls, voidwriteLogjstringjava_lang_StringID , s_);
+    curEnv->DeleteLocalRef(s_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-jstring fieldName_ = curEnv->NewStringUTF( fieldName );
-if (fieldName != NULL && fieldName_ == NULL)
+void ScilabJavaObject::setField (JavaVM * jvm_, int id, char const* fieldName, int idarg)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-                         curEnv->CallStaticVoidMethod(cls, voidsetFieldjintintjstringjava_lang_StringjintintID ,id, fieldName_, idarg);
-                        curEnv->DeleteLocalRef(fieldName_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+    static jmethodID voidsetFieldjintintjstringjava_lang_StringjintintID = curEnv->GetStaticMethodID(cls, "setField", "(ILjava/lang/String;I)V" ) ;
+    if (voidsetFieldjintintjstringjava_lang_StringjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "setField");
+    }
 
-int ScilabJavaObject::getField (JavaVM * jvm_, int id, char const* fieldName){
+    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 jintgetFieldjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "getField", "(ILjava/lang/String;)I" ) ;
-if (jintgetFieldjintintjstringjava_lang_StringID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "getField");
+    curEnv->CallStaticVoidMethod(cls, voidsetFieldjintintjstringjava_lang_StringjintintID , id, fieldName_, idarg);
+    curEnv->DeleteLocalRef(fieldName_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-jstring fieldName_ = curEnv->NewStringUTF( fieldName );
-if (fieldName != NULL && fieldName_ == NULL)
+int ScilabJavaObject::getField (JavaVM * jvm_, int id, char const* fieldName)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    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;
+    static jmethodID jintgetFieldjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "getField", "(ILjava/lang/String;)I" ) ;
+    if (jintgetFieldjintintjstringjava_lang_StringID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "getField");
+    }
 
-}
+    jstring fieldName_ = curEnv->NewStringUTF( fieldName );
+    if (fieldName != NULL && fieldName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-int ScilabJavaObject::getFieldType (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);
-}
+    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetFieldjintintjstringjava_lang_StringID , id, fieldName_));
+    curEnv->DeleteLocalRef(fieldName_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-jmethodID jintgetFieldTypejintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "getFieldType", "(ILjava/lang/String;)I" ) ;
-if (jintgetFieldTypejintintjstringjava_lang_StringID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "getFieldType");
 }
 
-jstring fieldName_ = curEnv->NewStringUTF( fieldName );
-if (fieldName != NULL && fieldName_ == NULL)
+int ScilabJavaObject::getFieldType (JavaVM * jvm_, int id, char const* fieldName)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(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;
+    static jmethodID jintgetFieldTypejintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "getFieldType", "(ILjava/lang/String;)I" ) ;
+    if (jintgetFieldTypejintintjstringjava_lang_StringID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "getFieldType");
+    }
 
-}
+    jstring fieldName_ = curEnv->NewStringUTF( fieldName );
+    if (fieldName != NULL && fieldName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-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);
-}
+    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetFieldTypejintintjstringjava_lang_StringID , id, fieldName_));
+    curEnv->DeleteLocalRef(fieldName_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-jmethodID jintjavaCastjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "javaCast", "(ILjava/lang/String;)I" ) ;
-if (jintjavaCastjintintjstringjava_lang_StringID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "javaCast");
 }
 
-jstring objName_ = curEnv->NewStringUTF( objName );
-if (objName != NULL && objName_ == NULL)
+int ScilabJavaObject::javaCast (JavaVM * jvm_, int id, char const* objName)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-                        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;
+    static jmethodID jintjavaCastjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "javaCast", "(ILjava/lang/String;)I" ) ;
+    if (jintjavaCastjintintjstringjava_lang_StringID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "javaCast");
+    }
 
-}
+    jstring objName_ = curEnv->NewStringUTF( objName );
+    if (objName != NULL && objName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-int ScilabJavaObject::javaCast (JavaVM * jvm_, int id, int classId){
 
-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, jintjavaCastjintintjstringjava_lang_StringID , id, objName_));
+    curEnv->DeleteLocalRef(objName_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-jmethodID jintjavaCastjintintjintintID = curEnv->GetStaticMethodID(cls, "javaCast", "(II)I" ) ;
-if (jintjavaCastjintintjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "javaCast");
 }
 
-                        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, int classId)
+{
 
-}
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-char* ScilabJavaObject::getClassName (JavaVM * jvm_, int id){
+    static jmethodID jintjavaCastjintintjintintID = curEnv->GetStaticMethodID(cls, "javaCast", "(II)I" ) ;
+    if (jintjavaCastjintintjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "javaCast");
+    }
 
-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, jintjavaCastjintintjintintID , id, classId));
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-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){
-
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
-if ( cls == NULL) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
+char* ScilabJavaObject::getClassName (JavaVM * jvm_, int id)
+{
 
-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 = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static 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);
+        if (curEnv->ExceptionCheck())
+        {
+            delete[] myStringBuffer;
+            throw GiwsException::JniCallMethodException(curEnv);
+        }
+        return myStringBuffer;
+    }
+    else
+    {
+        curEnv->DeleteLocalRef(res);
+        return NULL;
+    }
 }
 
-jintArray index_ = curEnv->NewIntArray( indexSize ) ;
-
-if (index_ == NULL)
+int ScilabJavaObject::getArrayElement (JavaVM * jvm_, int id, int const* index, int indexSize)
 {
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
-
-curEnv->SetIntArrayRegion( index_, 0, indexSize, (jint*)(index) ) ;
 
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-                        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;
+    static jmethodID jintgetArrayElementjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "getArrayElement", "(I[I)I" ) ;
+    if (jintgetArrayElementjintintjintArray_intintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "getArrayElement");
+    }
 
-}
+    jintArray index_ = curEnv->NewIntArray( indexSize ) ;
 
-void ScilabJavaObject::setArrayElement (JavaVM * jvm_, int id, int const* index, int indexSize, int idArg){
+    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_);
+    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) ) ;
-
-
-                         curEnv->CallStaticVoidMethod(cls, voidsetArrayElementjintintjintArray_intintjintintID ,id, index_, idArg);
-                        curEnv->DeleteLocalRef(index_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+void ScilabJavaObject::setArrayElement (JavaVM * jvm_, int id, int const* index, int indexSize, int idArg)
+{
 
-void ScilabJavaObject::removeScilabJavaObject (JavaVM * jvm_, int id){
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    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);
-}
+    static jmethodID voidsetArrayElementjintintjintArray_intintjintintID = curEnv->GetStaticMethodID(cls, "setArrayElement", "(I[II)V" ) ;
+    if (voidsetArrayElementjintintjintArray_intintjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "setArrayElement");
+    }
 
-jmethodID voidremoveScilabJavaObjectjintintID = curEnv->GetStaticMethodID(cls, "removeScilabJavaObject", "(I)V" ) ;
-if (voidremoveScilabJavaObjectjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "removeScilabJavaObject");
-}
+    jintArray index_ = curEnv->NewIntArray( indexSize ) ;
 
-                         curEnv->CallStaticVoidMethod(cls, voidremoveScilabJavaObjectjintintID ,id);
-                        curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+    if (index_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-void ScilabJavaObject::removeScilabJavaObject (JavaVM * jvm_, int const* id, int idSize){
+    curEnv->SetIntArrayRegion( index_, 0, indexSize, (jint*)(index) ) ;
 
-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 voidremoveScilabJavaObjectjintArray_intintID = curEnv->GetStaticMethodID(cls, "removeScilabJavaObject", "([I)V" ) ;
-if (voidremoveScilabJavaObjectjintArray_intintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "removeScilabJavaObject");
+    curEnv->CallStaticVoidMethod(cls, voidsetArrayElementjintintjintArray_intintjintintID , id, index_, idArg);
+    curEnv->DeleteLocalRef(index_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-jintArray id_ = curEnv->NewIntArray( idSize ) ;
-
-if (id_ == NULL)
+void ScilabJavaObject::removeScilabJavaObject (JavaVM * jvm_, int id)
 {
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
-curEnv->SetIntArrayRegion( id_, 0, idSize, (jint*)(id) ) ;
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
+    static jmethodID voidremoveScilabJavaObjectjintintID = curEnv->GetStaticMethodID(cls, "removeScilabJavaObject", "(I)V" ) ;
+    if (voidremoveScilabJavaObjectjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "removeScilabJavaObject");
+    }
 
-                         curEnv->CallStaticVoidMethod(cls, voidremoveScilabJavaObjectjintArray_intintID ,id_);
-                        curEnv->DeleteLocalRef(id_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
+    curEnv->CallStaticVoidMethod(cls, voidremoveScilabJavaObjectjintintID , id);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-void ScilabJavaObject::limitDirectBuffer (JavaVM * jvm_, int 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);
-}
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-jmethodID voidlimitDirectBufferjintintID = curEnv->GetStaticMethodID(cls, "limitDirectBuffer", "(I)V" ) ;
-if (voidlimitDirectBufferjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "limitDirectBuffer");
-}
+    static jmethodID voidremoveScilabJavaObjectjintArray_intintID = curEnv->GetStaticMethodID(cls, "removeScilabJavaObject", "([I)V" ) ;
+    if (voidremoveScilabJavaObjectjintArray_intintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "removeScilabJavaObject");
+    }
 
-                         curEnv->CallStaticVoidMethod(cls, voidlimitDirectBufferjintintID ,id);
-                        curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+    jintArray id_ = curEnv->NewIntArray( idSize ) ;
 
-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);
+    curEnv->CallStaticVoidMethod(cls, voidremoveScilabJavaObjectjintArray_intintID , id_);
+    curEnv->DeleteLocalRef(id_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
-return res;
 
-}
+void ScilabJavaObject::limitDirectBuffer (JavaVM * jvm_, int id)
+{
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, double x){
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    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);
-}
+    static jmethodID voidlimitDirectBufferjintintID = curEnv->GetStaticMethodID(cls, "limitDirectBuffer", "(I)V" ) ;
+    if (voidlimitDirectBufferjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "limitDirectBuffer");
+    }
 
-jmethodID jintwrapjdoubledoubleID = curEnv->GetStaticMethodID(cls, "wrap", "(D)I" ) ;
-if (jintwrapjdoubledoubleID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+    curEnv->CallStaticVoidMethod(cls, voidlimitDirectBufferjintintID , id);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjdoubledoubleID ,x));
-                        curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-return res;
+int ScilabJavaObject::isUnwrappable (JavaVM * jvm_, int id)
+{
 
-}
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, double const* x, int xSize){
+    static jmethodID jintisUnwrappablejintintID = curEnv->GetStaticMethodID(cls, "isUnwrappable", "(I)I" ) ;
+    if (jintisUnwrappablejintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "isUnwrappable");
+    }
 
-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, jintisUnwrappablejintintID , id));
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-jmethodID jintwrapjdoubleArray_doubledoubleID = curEnv->GetStaticMethodID(cls, "wrap", "([D)I" ) ;
-if (jintwrapjdoubleArray_doubledoubleID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-jdoubleArray x_ = curEnv->NewDoubleArray( xSize ) ;
-
-if (x_ == NULL)
+int ScilabJavaObject::wrap (JavaVM * jvm_, double x)
 {
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
-curEnv->SetDoubleArrayRegion( x_, 0, xSize, (jdouble*)(x) ) ;
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
+    static jmethodID jintwrapjdoubledoubleID = curEnv->GetStaticMethodID(cls, "wrap", "(D)I" ) ;
+    if (jintwrapjdoubledoubleID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+    }
 
-                        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_, 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);
-}
+    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjdoubledoubleID , x));
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-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)
+int ScilabJavaObject::wrap (JavaVM * jvm_, double const* x, int xSize)
 {
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
-
- for (int i=0; i<xSize; i++){
 
-jdoubleArray xLocal = curEnv->NewDoubleArray( xSizeCol ) ;
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-if (xLocal == NULL)
-{
-// check that allocation succeed
-curEnv->DeleteLocalRef(x_);
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    static jmethodID jintwrapjdoubleArray_doubledoubleID = curEnv->GetStaticMethodID(cls, "wrap", "([D)I" ) ;
+    if (jintwrapjdoubleArray_doubledoubleID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+    }
 
-curEnv->SetDoubleArrayRegion( xLocal, 0, xSizeCol, (jdouble*)(x[i]) ) ;
-curEnv->SetObjectArrayElement(x_, i, xLocal);
-curEnv->DeleteLocalRef(xLocal);
-}
+    jdoubleArray x_ = curEnv->NewDoubleArray( xSize ) ;
 
-                        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;
+    if (x_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-}
+    curEnv->SetDoubleArrayRegion( x_, 0, xSize, (jdouble*)(x) ) ;
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, int 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, jintwrapjdoubleArray_doubledoubleID , x_));
+    curEnv->DeleteLocalRef(x_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-jmethodID jintwrapjintintID = curEnv->GetStaticMethodID(cls, "wrap", "(I)I" ) ;
-if (jintwrapjintintID == 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;
+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 = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static 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);
+        }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, int const* x, int xSize){
+        curEnv->SetDoubleArrayRegion( xLocal, 0, xSizeCol, (jdouble*)(x[i]) ) ;
+        curEnv->SetObjectArrayElement(x_, i, xLocal);
+        curEnv->DeleteLocalRef(xLocal);
+    }
 
-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, jintwrapjobjectArray__doubledoubleID , x_));
+    curEnv->DeleteLocalRef(x_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-jmethodID jintwrapjintArray_intintID = curEnv->GetStaticMethodID(cls, "wrap", "([I)I" ) ;
-if (jintwrapjintArray_intintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-jintArray x_ = curEnv->NewIntArray( xSize ) ;
-
-if (x_ == NULL)
+int ScilabJavaObject::wrap (JavaVM * jvm_, int x)
 {
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
-
-curEnv->SetIntArrayRegion( x_, 0, xSize, (jint*)(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 = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, int const* const* x, int xSize, int xSizeCol){
+    static jmethodID jintwrapjintintID = curEnv->GetStaticMethodID(cls, "wrap", "(I)I" ) ;
+    if (jintwrapjintintID == 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, jintwrapjintintID , x));
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-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)
+int ScilabJavaObject::wrap (JavaVM * jvm_, int const* x, int xSize)
 {
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
- for (int i=0; i<xSize; i++){
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-jintArray xLocal = curEnv->NewIntArray( xSizeCol ) ;
+    static 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->SetIntArrayRegion( xLocal, 0, xSizeCol, (jint*)(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__intintID ,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_, 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);
-}
+    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjintArray_intintID , x_));
+    curEnv->DeleteLocalRef(x_);
+    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 = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static 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);
+        }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, byte const* x, int xSize){
+        curEnv->SetIntArrayRegion( xLocal, 0, xSizeCol, (jint*)(x[i]) ) ;
+        curEnv->SetObjectArrayElement(x_, i, xLocal);
+        curEnv->DeleteLocalRef(xLocal);
+    }
 
-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, jintwrapjobjectArray__intintID , x_));
+    curEnv->DeleteLocalRef(x_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-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)
+int ScilabJavaObject::wrap (JavaVM * jvm_, byte x)
 {
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
-
-curEnv->SetByteArrayRegion( x_, 0, xSize, (jbyte*)(x) ) ;
-
 
-                        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;
-
-}
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, byte const* const* x, int xSize, int xSizeCol){
+    static 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);
-}
+    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbytebyteID , x));
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-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)
+int ScilabJavaObject::wrap (JavaVM * jvm_, byte const* x, int xSize)
 {
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
- for (int i=0; i<xSize; i++){
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-jbyteArray xLocal = curEnv->NewByteArray( xSizeCol ) ;
+    static jmethodID jintwrapjbyteArray_bytebyteID = curEnv->GetStaticMethodID(cls, "wrap", "([B)I" ) ;
+    if (jintwrapjbyteArray_bytebyteID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+    }
 
-if (xLocal == NULL)
-{
-// check that allocation succeed
-curEnv->DeleteLocalRef(x_);
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    jbyteArray x_ = curEnv->NewByteArray( xSize ) ;
 
-curEnv->SetByteArrayRegion( xLocal, 0, xSizeCol, (jbyte*)(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__bytebyteID ,x_));
-                        curEnv->DeleteLocalRef(x_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-return res;
-
-}
+    curEnv->SetByteArrayRegion( x_, 0, xSize, (jbyte*)(x) ) ;
 
-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);
-}
+    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbyteArray_bytebyteID , x_));
+    curEnv->DeleteLocalRef(x_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-jmethodID jintwrapjshortshortID = curEnv->GetStaticMethodID(cls, "wrap", "(S)I" ) ;
-if (jintwrapjshortshortID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-                        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 = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static 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);
+        }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, short const* x, int xSize){
+        curEnv->SetByteArrayRegion( xLocal, 0, xSizeCol, (jbyte*)(x[i]) ) ;
+        curEnv->SetObjectArrayElement(x_, i, xLocal);
+        curEnv->DeleteLocalRef(xLocal);
+    }
 
-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, jintwrapjobjectArray__bytebyteID , x_));
+    curEnv->DeleteLocalRef(x_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-jmethodID jintwrapjshortArray_shortshortID = curEnv->GetStaticMethodID(cls, "wrap", "([S)I" ) ;
-if (jintwrapjshortArray_shortshortID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-jshortArray x_ = curEnv->NewShortArray( xSize ) ;
-
-if (x_ == NULL)
+int ScilabJavaObject::wrap (JavaVM * jvm_, short x)
 {
-// 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 = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-                        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;
-
-}
+    static jmethodID jintwrapjshortshortID = curEnv->GetStaticMethodID(cls, "wrap", "(S)I" ) ;
+    if (jintwrapjshortshortID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+    }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, short const* const* x, int xSize, int xSizeCol){
+    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjshortshortID , x));
+    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");
-}
-
- jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[S"),NULL);
-
-if (x_ == NULL)
+int ScilabJavaObject::wrap (JavaVM * jvm_, short const* x, int xSize)
 {
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
- for (int i=0; i<xSize; i++){
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-jshortArray xLocal = curEnv->NewShortArray( xSizeCol ) ;
+    static jmethodID jintwrapjshortArray_shortshortID = curEnv->GetStaticMethodID(cls, "wrap", "([S)I" ) ;
+    if (jintwrapjshortArray_shortshortID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+    }
 
-if (xLocal == NULL)
-{
-// check that allocation succeed
-curEnv->DeleteLocalRef(x_);
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    jshortArray x_ = curEnv->NewShortArray( xSize ) ;
 
-curEnv->SetShortArrayRegion( xLocal, 0, xSizeCol, (jshort*)(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__shortshortID ,x_));
-                        curEnv->DeleteLocalRef(x_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-return res;
+    curEnv->SetShortArrayRegion( x_, 0, xSize, (jshort*)(x) ) ;
 
-}
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, char const* x){
+    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjshortArray_shortshortID , x_));
+    curEnv->DeleteLocalRef(x_);
+    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");
-}
-
-jstring x_ = curEnv->NewStringUTF( x );
-if (x != NULL && x_ == NULL)
+int ScilabJavaObject::wrap (JavaVM * jvm_, short const* const* x, int xSize, int xSizeCol)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
-
-
-                        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;
 
-}
-
-int ScilabJavaObject::wrap (JavaVM * jvm_, char const* const* x, int xSize){
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static 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);
+        }
 
-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->SetShortArrayRegion( xLocal, 0, xSizeCol, (jshort*)(x[i]) ) ;
+        curEnv->SetObjectArrayElement(x_, i, xLocal);
+        curEnv->DeleteLocalRef(xLocal);
+    }
 
-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");
+    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__shortshortID , x_));
+    curEnv->DeleteLocalRef(x_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-// 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++)
+int ScilabJavaObject::wrap (JavaVM * jvm_, char const* x)
 {
-jstring TempString = curEnv->NewStringUTF( x[i] );
-if (TempString == NULL)
-{
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
-curEnv->SetObjectArrayElement( x_, i, TempString);
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-// 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;
+    static jmethodID jintwrapjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "wrap", "(Ljava/lang/String;)I" ) ;
+    if (jintwrapjstringjava_lang_StringID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+    }
 
-}
+    jstring x_ = curEnv->NewStringUTF( x );
+    if (x != NULL && x_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-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);
-}
+    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjstringjava_lang_StringID , x_));
+    curEnv->DeleteLocalRef(x_);
+    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 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)
+int ScilabJavaObject::wrap (JavaVM * jvm_, char const* const* x, int xSize)
 {
-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);
-
-}
-                        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_, bool 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 jintwrapjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "wrap", "(Z)I" ) ;
-if (jintwrapjbooleanbooleanID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-}
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static 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);
+        }
 
-jboolean x_ = (static_cast<bool>(x) ? JNI_TRUE : JNI_FALSE);
+        curEnv->SetObjectArrayElement( x_, i, TempString);
 
-                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbooleanbooleanID ,x_));
-                        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, jintwrapjobjectArray_java_lang_Stringjava_lang_StringID , x_));
+    curEnv->DeleteLocalRef(stringArrayClass);
+    curEnv->DeleteLocalRef(x_);
+    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_, char const* 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 = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static 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);
 
-jbooleanArray x_ = curEnv->NewBooleanArray( xSize ) ;
-curEnv->SetBooleanArrayRegion( x_, 0, xSize, (jboolean*)x ) ;
+    }
+    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__java_lang_Stringjava_lang_StringID , x_));
+    curEnv->DeleteLocalRef(stringArrayClass);
+    curEnv->DeleteLocalRef(x_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-                        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_, bool x)
+{
 
-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 = initClass(curEnv);
+    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);
-}
+    static jmethodID jintwrapjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "wrap", "(Z)I" ) ;
+    if (jintwrapjbooleanbooleanID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+    }
 
-jmethodID jintwrapjobjectArray__booleanbooleanID = curEnv->GetStaticMethodID(cls, "wrap", "([[Z)I" ) ;
-if (jintwrapjobjectArray__booleanbooleanID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-}
+    jboolean x_ = (static_cast<bool>(x) ? JNI_TRUE : JNI_FALSE);
 
-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;
+    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbooleanbooleanID , x_));
+    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);
-}
-
-jmethodID jintwrapjcharcharID = curEnv->GetStaticMethodID(cls, "wrap", "(C)I" ) ;
-if (jintwrapjcharcharID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-}
+int ScilabJavaObject::wrap (JavaVM * jvm_, bool const* x, int xSize)
+{
 
-                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjcharcharID ,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 = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-}
+    static jmethodID jintwrapjbooleanArray_booleanbooleanID = curEnv->GetStaticMethodID(cls, "wrap", "([Z)I" ) ;
+    if (jintwrapjbooleanArray_booleanbooleanID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+    }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, unsigned short const* x, int xSize){
+    jbooleanArray x_ = curEnv->NewBooleanArray( xSize ) ;
+    curEnv->SetBooleanArrayRegion( x_, 0, xSize, (jboolean*)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, jintwrapjbooleanArray_booleanbooleanID , x_));
+    curEnv->DeleteLocalRef(x_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-jmethodID jintwrapjcharArray_charcharID = curEnv->GetStaticMethodID(cls, "wrap", "([C)I" ) ;
-if (jintwrapjcharArray_charcharID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-jcharArray x_ = curEnv->NewCharArray( xSize ) ;
-
-if (x_ == NULL)
+int ScilabJavaObject::wrap (JavaVM * jvm_, bool const* const* x, int xSize, int xSizeCol)
 {
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
-curEnv->SetCharArrayRegion( x_, 0, xSize, (jchar*)(x) ) ;
-
-
-                        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;
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static 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_);
+    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 = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, unsigned short const* const* x, int xSize, int xSizeCol){
+    static jmethodID jintwrapjcharcharID = curEnv->GetStaticMethodID(cls, "wrap", "(C)I" ) ;
+    if (jintwrapjcharcharID == 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, jintwrapjcharcharID , x));
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-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)
+int ScilabJavaObject::wrap (JavaVM * jvm_, unsigned short const* x, int xSize)
 {
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
-
- for (int i=0; i<xSize; i++){
 
-jcharArray xLocal = curEnv->NewCharArray( xSizeCol ) ;
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-if (xLocal == NULL)
-{
-// check that allocation succeed
-curEnv->DeleteLocalRef(x_);
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    static jmethodID jintwrapjcharArray_charcharID = curEnv->GetStaticMethodID(cls, "wrap", "([C)I" ) ;
+    if (jintwrapjcharArray_charcharID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+    }
 
-curEnv->SetCharArrayRegion( xLocal, 0, xSizeCol, (jchar*)(x[i]) ) ;
-curEnv->SetObjectArrayElement(x_, i, xLocal);
-curEnv->DeleteLocalRef(xLocal);
-}
+    jcharArray x_ = curEnv->NewCharArray( xSize ) ;
 
-                        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;
+    if (x_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-}
+    curEnv->SetCharArrayRegion( x_, 0, xSize, (jchar*)(x) ) ;
 
-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);
-}
+    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjcharArray_charcharID , x_));
+    curEnv->DeleteLocalRef(x_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-jmethodID jintwrapjfloatfloatID = curEnv->GetStaticMethodID(cls, "wrap", "(F)I" ) ;
-if (jintwrapjfloatfloatID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-                        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* const* x, int xSize, int xSizeCol)
+{
 
-}
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static 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);
+        }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, float const* x, int xSize){
+        curEnv->SetCharArrayRegion( xLocal, 0, xSizeCol, (jchar*)(x[i]) ) ;
+        curEnv->SetObjectArrayElement(x_, i, xLocal);
+        curEnv->DeleteLocalRef(xLocal);
+    }
 
-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, jintwrapjobjectArray__charcharID , x_));
+    curEnv->DeleteLocalRef(x_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-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)
+int ScilabJavaObject::wrap (JavaVM * jvm_, float x)
 {
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
-
-curEnv->SetFloatArrayRegion( x_, 0, xSize, (jfloat*)(x) ) ;
-
 
-                        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;
-
-}
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, float const* const* x, int xSize, int xSizeCol){
+    static 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));
+    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)
+int ScilabJavaObject::wrap (JavaVM * jvm_, float const* x, int xSize)
 {
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
- for (int i=0; i<xSize; i++){
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-jfloatArray xLocal = curEnv->NewFloatArray( xSizeCol ) ;
-
-if (xLocal == NULL)
-{
-// check that allocation succeed
-curEnv->DeleteLocalRef(x_);
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    static jmethodID jintwrapjfloatArray_floatfloatID = curEnv->GetStaticMethodID(cls, "wrap", "([F)I" ) ;
+    if (jintwrapjfloatArray_floatfloatID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+    }
 
-curEnv->SetFloatArrayRegion( xLocal, 0, xSizeCol, (jfloat*)(x[i]) ) ;
-curEnv->SetObjectArrayElement(x_, i, xLocal);
-curEnv->DeleteLocalRef(xLocal);
-}
+    jfloatArray x_ = curEnv->NewFloatArray( xSize ) ;
 
-                        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;
+    if (x_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-}
+    curEnv->SetFloatArrayRegion( x_, 0, xSize, (jfloat*)(x) ) ;
 
-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);
-}
+    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjfloatArray_floatfloatID , x_));
+    curEnv->DeleteLocalRef(x_);
+    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* const* x, int xSize, int xSizeCol)
+{
 
-}
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static 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);
+        }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, long long const* x, int xSize){
+        curEnv->SetFloatArrayRegion( xLocal, 0, xSizeCol, (jfloat*)(x[i]) ) ;
+        curEnv->SetObjectArrayElement(x_, i, xLocal);
+        curEnv->DeleteLocalRef(xLocal);
+    }
 
-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, jintwrapjobjectArray__floatfloatID , x_));
+    curEnv->DeleteLocalRef(x_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-jmethodID jintwrapjlongArray_longlongID = curEnv->GetStaticMethodID(cls, "wrap", "([J)I" ) ;
-if (jintwrapjlongArray_longlongID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-jlongArray x_ = curEnv->NewLongArray( xSize ) ;
-
-if (x_ == NULL)
+int ScilabJavaObject::wrap (JavaVM * jvm_, long long x)
 {
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
-
-curEnv->SetLongArrayRegion( x_, 0, xSize, (jlong*)(x) ) ;
 
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    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;
-
-}
+    static jmethodID jintwrapjlonglongID = curEnv->GetStaticMethodID(cls, "wrap", "(J)I" ) ;
+    if (jintwrapjlonglongID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+    }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, long long const* const* x, int xSize, int xSizeCol){
+    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjlonglongID , x));
+    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__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)
+int ScilabJavaObject::wrap (JavaVM * jvm_, long long const* x, int xSize)
 {
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
-
- for (int i=0; i<xSize; i++){
 
-jlongArray xLocal = curEnv->NewLongArray( xSizeCol ) ;
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-if (xLocal == NULL)
-{
-// check that allocation succeed
-curEnv->DeleteLocalRef(x_);
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    static jmethodID jintwrapjlongArray_longlongID = curEnv->GetStaticMethodID(cls, "wrap", "([J)I" ) ;
+    if (jintwrapjlongArray_longlongID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+    }
 
-curEnv->SetLongArrayRegion( xLocal, 0, xSizeCol, (jlong*)(x[i]) ) ;
-curEnv->SetObjectArrayElement(x_, i, xLocal);
-curEnv->DeleteLocalRef(xLocal);
-}
+    jlongArray x_ = curEnv->NewLongArray( 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;
+    if (x_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-}
+    curEnv->SetLongArrayRegion( x_, 0, xSize, (jlong*)(x) ) ;
 
-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);
-}
+    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjlongArray_longlongID , x_));
+    curEnv->DeleteLocalRef(x_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-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;
-}
-}
+int ScilabJavaObject::wrap (JavaVM * jvm_, long long const* const* x, int xSize, int xSizeCol)
+{
 
-char** ScilabJavaObject::getAccessibleMethods (JavaVM * jvm_, int id, int *lenRow){
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static 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);
+        }
 
-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->SetLongArrayRegion( xLocal, 0, xSizeCol, (jlong*)(x[i]) ) ;
+        curEnv->SetObjectArrayElement(x_, i, xLocal);
+        curEnv->DeleteLocalRef(xLocal);
+    }
 
-jmethodID jobjectArray_getAccessibleMethodsjintintID = curEnv->GetStaticMethodID(cls, "getAccessibleMethods", "(I)[Ljava/lang/String;" ) ;
-if (jobjectArray_getAccessibleMethodsjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "getAccessibleMethods");
-}
+    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__longlongID , x_));
+    curEnv->DeleteLocalRef(x_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
-                        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);
-}
+char** ScilabJavaObject::getAccessibleFields (JavaVM * jvm_, int id, int *lenRow)
+{
 
-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");
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static 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);
+        }
+        if (curEnv->ExceptionCheck())
+        {
+            delete[] arrayOfString;
+            throw GiwsException::JniCallMethodException(curEnv);
+        }
+        curEnv->DeleteLocalRef(res);
+        return arrayOfString;
+    }
+    else
+    {
+        curEnv->DeleteLocalRef(res);
+        return NULL;
+    }
 }
-jclass stringArrayClass = curEnv->FindClass("java/lang/String");
 
-// create java array of strings.
-jobjectArray fieldPath_ = curEnv->NewObjectArray( fieldPathSize, stringArrayClass, NULL);
-if (fieldPath_ == NULL)
+char** ScilabJavaObject::getAccessibleMethods (JavaVM * jvm_, int id, int *lenRow)
 {
-throw GiwsException::JniBadAllocException(curEnv);
+
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static 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);
+        }
+        if (curEnv->ExceptionCheck())
+        {
+            delete[] arrayOfString;
+            throw GiwsException::JniCallMethodException(curEnv);
+        }
+        curEnv->DeleteLocalRef(res);
+        return arrayOfString;
+    }
+    else
+    {
+        curEnv->DeleteLocalRef(res);
+        return NULL;
+    }
 }
 
-// convert each char * to java strings and fill the java array.
-for ( int i = 0; i < fieldPathSize; i++)
+char** ScilabJavaObject::getCompletion (JavaVM * jvm_, int id, char const* const* fieldPath, int fieldPathSize, int *lenRow)
 {
-jstring TempString = curEnv->NewStringUTF( fieldPath[i] );
-if (TempString == NULL)
-{
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
-curEnv->SetObjectArrayElement( fieldPath_, i, TempString);
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static 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);
+        }
 
-// 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_);
+        if (curEnv->ExceptionCheck())
+        {
+            delete[] arrayOfString;
+            throw GiwsException::JniCallMethodException(curEnv);
+        }
+        curEnv->DeleteLocalRef(res);
+        return arrayOfString;
+    }
+    else
+    {
+        curEnv->DeleteLocalRef(res);
+        return NULL;
+    }
 }
 
 }
index a2903c2..1401d89 100644 (file)
@@ -1,5 +1,5 @@
 /* Generated by GIWS (version 2.0.2) with command:
-giws -e -f ScilabObjects.giws.xml 
+giws --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/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,243 +69,267 @@ knowledge of the CeCILL-B license and that you accept its terms.
 # 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_);
+    // 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
 
-/**
-* 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);
+
+    static char** getInfos(JavaVM * jvm_, int *lenRow);
+
+    static void initScilabJavaObject(JavaVM * jvm_);
+
+    static void garbageCollect(JavaVM * jvm_);
+
+    static char* getRepresentation(JavaVM * jvm_, int id);
 
-// Methods
-static int invoke(JavaVM * jvm_, int id, char const* methodName, int const* args, int argsSize);
+    static bool isValidJavaObject(JavaVM * jvm_, int id);
 
-static int extract(JavaVM * jvm_, int id, int const* args, int argsSize);
+    static void enableTrace(JavaVM * jvm_, char const* filename);
 
-static void insert(JavaVM * jvm_, int id, int const* keys, int keysSize, int value);
+    static void disableTrace(JavaVM * jvm_);
 
-static char** getInfos(JavaVM * jvm_, int *lenRow);
+    static void writeLog(JavaVM * jvm_, char const* s);
 
-static void initScilabJavaObject(JavaVM * jvm_);
+    static void setField(JavaVM * jvm_, int id, char const* fieldName, int idarg);
 
-static void garbageCollect(JavaVM * jvm_);
+    static int getField(JavaVM * jvm_, int id, char const* fieldName);
 
-static char* getRepresentation(JavaVM * jvm_, int id);
+    static int getFieldType(JavaVM * jvm_, int id, char const* fieldName);
 
-static bool isValidJavaObject(JavaVM * jvm_, int id);
+    static int javaCast(JavaVM * jvm_, int id, char const* objName);
 
-static void enableTrace(JavaVM * jvm_, char const* filename);
+    static int javaCast(JavaVM * jvm_, int id, int classId);
 
-static void disableTrace(JavaVM * jvm_);
+    static char* getClassName(JavaVM * jvm_, int id);
 
-static void writeLog(JavaVM * jvm_, char const* s);
+    static int getArrayElement(JavaVM * jvm_, int id, int const* index, int indexSize);
 
-static void setField(JavaVM * jvm_, int id, char const* fieldName, int idarg);
+    static void setArrayElement(JavaVM * jvm_, int id, int const* index, int indexSize, int idArg);
 
-static int getField(JavaVM * jvm_, int id, char const* fieldName);
+    static void removeScilabJavaObject(JavaVM * jvm_, int id);
 
-static int getFieldType(JavaVM * jvm_, int id, char const* fieldName);
+    static void removeScilabJavaObject(JavaVM * jvm_, int const* id, int idSize);
 
-static int javaCast(JavaVM * jvm_, int id, char const* objName);
+    static void limitDirectBuffer(JavaVM * jvm_, int id);
 
-static int javaCast(JavaVM * jvm_, int id, int classId);
+    static int isUnwrappable(JavaVM * jvm_, int id);
 
-static char* getClassName(JavaVM * jvm_, int id);
+    static int wrap(JavaVM * jvm_, double x);
 
-static int getArrayElement(JavaVM * jvm_, int id, int const* index, int indexSize);
+    static int wrap(JavaVM * jvm_, double const* x, int xSize);
 
-static void setArrayElement(JavaVM * jvm_, int id, int const* index, int indexSize, int idArg);
+    static int wrap(JavaVM * jvm_, double const* const* x, int xSize, int xSizeCol);
 
-static void removeScilabJavaObject(JavaVM * jvm_, int id);
+    static int wrap(JavaVM * jvm_, int x);
 
-static void removeScilabJavaObject(JavaVM * jvm_, int const* id, int idSize);
+    static int wrap(JavaVM * jvm_, int const* x, int xSize);
 
-static void limitDirectBuffer(JavaVM * jvm_, int id);
+    static int wrap(JavaVM * jvm_, int const* const* x, int xSize, int xSizeCol);
 
-static int isUnwrappable(JavaVM * jvm_, int id);
+    static int wrap(JavaVM * jvm_, byte x);
 
-static int wrap(JavaVM * jvm_, double x);
+    static int wrap(JavaVM * jvm_, byte const* x, int xSize);
 
-static int wrap(JavaVM * jvm_, double const* x, int xSize);
+    static int wrap(JavaVM * jvm_, byte const* const* x, int xSize, int xSizeCol);
 
-static int wrap(JavaVM * jvm_, double const* const* x, int xSize, int xSizeCol);
+    static int wrap(JavaVM * jvm_, short x);
 
-static int wrap(JavaVM * jvm_, int x);
+    static int wrap(JavaVM * jvm_, short const* x, int xSize);
 
-static int wrap(JavaVM * jvm_, int const* x, int xSize);
+    static int wrap(JavaVM * jvm_, short 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_, char const* x);
 
-static int wrap(JavaVM * jvm_, byte x);
+    static int wrap(JavaVM * jvm_, char const* const* x, int xSize);
 
-static int wrap(JavaVM * jvm_, byte const* x, int xSize);
+    static int wrap(JavaVM * jvm_, char const* 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_, bool x);
 
-static int wrap(JavaVM * jvm_, short x);
+    static int wrap(JavaVM * jvm_, bool const* x, int xSize);
 
-static int wrap(JavaVM * jvm_, short const* x, int xSize);
+    static int wrap(JavaVM * jvm_, bool 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_, unsigned short x);
 
-static int wrap(JavaVM * jvm_, char const* x);
+    static int wrap(JavaVM * jvm_, unsigned short const* x, int xSize);
 
-static int wrap(JavaVM * jvm_, char const* const* x, int xSize);
+    static int wrap(JavaVM * jvm_, unsigned 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_, float x);
 
-static int wrap(JavaVM * jvm_, bool x);
+    static int wrap(JavaVM * jvm_, float const* x, int xSize);
 
-static int wrap(JavaVM * jvm_, bool const* x, int xSize);
+    static int wrap(JavaVM * jvm_, float 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_, long long x);
 
-static int wrap(JavaVM * jvm_, unsigned short x);
+    static int wrap(JavaVM * jvm_, long long const* x, int xSize);
 
-static int wrap(JavaVM * jvm_, unsigned short const* x, int xSize);
+    static int wrap(JavaVM * jvm_, long long const* const* x, int xSize, int xSizeCol);
 
-static int wrap(JavaVM * jvm_, unsigned short const* const* x, int xSize, int xSizeCol);
+    static char** getAccessibleFields(JavaVM * jvm_, int id, int *lenRow);
 
-static int wrap(JavaVM * jvm_, float x);
+    static char** getAccessibleMethods(JavaVM * jvm_, int id, int *lenRow);
 
-static int wrap(JavaVM * jvm_, float const* x, int xSize);
+    static char** getCompletion(JavaVM * jvm_, int id, char const* const* fieldPath, int fieldPathSize, int *lenRow);
 
-static int wrap(JavaVM * jvm_, float const* const* x, int xSize, int xSizeCol);
 
-static int wrap(JavaVM * jvm_, long long x);
+    /**
+    * Get class name to use for static methods
+    * @return class name to use for static methods
+    */
 
-static int wrap(JavaVM * jvm_, long long const* x, int xSize);
+    static const std::string className()
+    {
+        return "org/scilab/modules/external_objects_java/ScilabJavaObject";
+    }
 
-static int wrap(JavaVM * jvm_, long long const* const* x, int xSize, int xSizeCol);
 
-static char** getAccessibleFields(JavaVM * jvm_, int id, int *lenRow);
+    /**
+    * Get class to use for static methods
+    * @return class to use for static methods
+    */
 
-static char** getAccessibleMethods(JavaVM * jvm_, int id, int *lenRow);
+    static jclass initClass(JNIEnv * curEnv)
+    {
+        static jclass cls = 0;
 
-static char** getCompletion(JavaVM * jvm_, int id, char const* const* fieldPath, int fieldPathSize, int *lenRow);
+        if (cls == 0)
+        {
+            jclass _cls = curEnv->FindClass(className().c_str());
+            if (_cls)
+            {
+                cls = static_cast<jclass>(curEnv->NewGlobalRef(_cls));
+            }
+        }
 
+        return cls;
+    }
 
-                        /**
-                        * 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 e1afe2b..1ecfb0d 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 --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/ScilabObjects.giws.xml
 */
 /*
 
@@ -36,136 +36,156 @@ 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 {
+namespace org_scilab_modules_external_objects_java
+{
+
+// Static declarations (if any)
 
-                // 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());
-}
+    localClass = curEnv->FindClass( this->className().c_str() ) ;
+    if (localClass == NULL)
+    {
+        throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+    }
 
-this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
 
-/* localClass is not needed anymore */
-curEnv->DeleteLocalRef(localClass);
+    /* localClass is not needed anymore */
+    curEnv->DeleteLocalRef(localClass);
 
-if (this->instanceClass == NULL) {
-throw GiwsException::JniObjectCreationException(curEnv, this->className());
-}
+    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());
-}
+    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);
+    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 = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static 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));
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    return res;
 
 }
 
index d3d2be1..0bb4abb 100644 (file)
@@ -1,5 +1,5 @@
 /* Generated by GIWS (version 2.0.2) with command:
-giws -e -f ScilabObjects.giws.xml 
+giws --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/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,86 +69,110 @@ knowledge of the CeCILL-B license and that you accept its terms.
 # 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_);
+    // 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
 
-/**
-* 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);
+    // Destructor
+    ~ScilabOperations();
 
+    // 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
-ScilabOperations(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
-#endif
+    /**
+    * Exit monitor associated with the object.
+    * Equivalent of ending a "synchronized(obj)" scope.
+    */
+    void endSynchronize();
 
-// Destructor
-~ScilabOperations();
+    // Methods
+    static int add(JavaVM * jvm_, int idA, int idB);
 
-// 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";
-                }
-                
+    /**
+    * 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";
+    }
+
+
+    /**
+    * Get class to use for static methods
+    * @return class to use for static methods
+    */
+
+    static jclass initClass(JNIEnv * curEnv)
+    {
+        static jclass cls = 0;
+
+        if (cls == 0)
+        {
+            jclass _cls = curEnv->FindClass(className().c_str());
+            if (_cls)
+            {
+                cls = static_cast<jclass>(curEnv->NewGlobalRef(_cls));
+            }
+        }
+
+        return cls;
+    }
+
 };
 
 
index 6a53655..fdc252e 100644 (file)
@@ -1,6 +1,6 @@
 #include "Driver.hxx"
-/* Generated by GIWS (version 2.0.1) with command:
-giws --disable-return-size-array --output-dir D:\git\debug\master\scilab\modules\graphic_export\src\jni\ --throws-exception-on-error --description-file Driver.giws.xml 
+/* Generated by GIWS (version 2.0.2) with command:
+giws --disable-return-size-array --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/Driver.giws.xml
 */
 /*
 
@@ -10,16 +10,16 @@ This software is a computer program whose purpose is to hide the complexity
 of accessing Java objects/methods from C++ code.
 
 This software is governed by the CeCILL-B license under French law and
-abiding by the rules of distribution of free software.  You can  use, 
+abiding by the rules of distribution of free software.  You can  use,
 modify and/ or redistribute the software under the terms of the CeCILL-B
 license as circulated by CEA, CNRS and INRIA at the following URL
-"http://www.cecill.info". 
+"http://www.cecill.info".
 
 As a counterpart to the access to the source code and  rights to copy,
 modify and redistribute granted by the license, users are provided only
 with a limited warranty  and the software's author,  the holder of the
 economic rights,  and the successive licensors  have only  limited
-liability. 
+liability.
 
 In this respect, the user's attention is drawn to the risks associated
 with loading,  using,  modifying and/or developing or reproducing the
@@ -28,249 +28,299 @@ that may mean  that it is complicated to manipulate,  and  that  also
 therefore means  that it is reserved for developers  and  experienced
 professionals having in-depth computer knowledge. Users are therefore
 encouraged to load and test the software's suitability as regards their
-requirements in conditions enabling the security of their systems and/or 
-data to be ensured and,  more generally, to use and operate it in the 
-same conditions as regards security. 
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
 
 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_graphic_export {
+namespace org_scilab_modules_graphic_export
+{
+
+// Static declarations (if any)
 
-                // Static declarations (if any)
-                
 // Returns the current env
 
-JNIEnv * Driver::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 * Driver::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
 
-Driver::~Driver() {
-JNIEnv * curEnv = NULL;
-this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-
-curEnv->DeleteGlobalRef(this->instance);
-curEnv->DeleteGlobalRef(this->instanceClass);
+Driver::~Driver()
+{
+    JNIEnv * curEnv = NULL;
+    this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    curEnv->DeleteGlobalRef(this->instance);
+    curEnv->DeleteGlobalRef(this->instanceClass);
 }
 // Constructors
-Driver::Driver(JavaVM * jvm_) {
-jmethodID constructObject = NULL ;
-jobject localInstance ;
-jclass localClass ;
+Driver::Driver(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());
-}
+    localClass = curEnv->FindClass( this->className().c_str() ) ;
+    if (localClass == NULL)
+    {
+        throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+    }
 
-this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
 
-/* localClass is not needed anymore */
-curEnv->DeleteLocalRef(localClass);
+    /* localClass is not needed anymore */
+    curEnv->DeleteLocalRef(localClass);
 
-if (this->instanceClass == NULL) {
-throw GiwsException::JniObjectCreationException(curEnv, this->className());
-}
+    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());
-}
+    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);
+    localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
+    if (localInstance == NULL)
+    {
+        throw GiwsException::JniObjectCreationException(curEnv, this->className());
+    }
 
-                /* Methods ID set to NULL */
-jbooleansetDriverjstringjava_lang_StringID=NULL;
-jstringgetDriverID=NULL;
-voidsetPathjstringjava_lang_StringID=NULL;
-jstringendjintintID=NULL;
+    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 */
+    jbooleansetDriverjstringjava_lang_StringID = NULL;
+    jstringgetDriverID = NULL;
+    voidsetPathjstringjava_lang_StringID = NULL;
+    jstringendjintintID = NULL;
 
 
 }
 
-Driver::Driver(JavaVM * jvm_, jobject JObj) {
-        jvm=jvm_;
+Driver::Driver(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 */
-        jbooleansetDriverjstringjava_lang_StringID=NULL;
-jstringgetDriverID=NULL;
-voidsetPathjstringjava_lang_StringID=NULL;
-jstringendjintintID=NULL;
+    this->instance = curEnv->NewGlobalRef(JObj) ;
+    if (this->instance == NULL)
+    {
+        throw GiwsException::JniObjectCreationException(curEnv, this->className());
+    }
+    /* Methods ID set to NULL */
+    jbooleansetDriverjstringjava_lang_StringID = NULL;
+    jstringgetDriverID = NULL;
+    voidsetPathjstringjava_lang_StringID = NULL;
+    jstringendjintintID = NULL;
 
 
 }
 
 // Generic methods
 
-void Driver::synchronize() {
-if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
-throw GiwsException::JniMonitorException(getCurrentEnv(), "Driver");
-}
+void Driver::synchronize()
+{
+    if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK)
+    {
+        throw GiwsException::JniMonitorException(getCurrentEnv(), "Driver");
+    }
 }
 
-void Driver::endSynchronize() {
-if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
-throw GiwsException::JniMonitorException(getCurrentEnv(), "Driver");
-}
+void Driver::endSynchronize()
+{
+    if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK)
+    {
+        throw GiwsException::JniMonitorException(getCurrentEnv(), "Driver");
+    }
 }
 // Method(s)
 
-bool Driver::setDriver (JavaVM * jvm_, char const* driver){
-
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
-
-jmethodID jbooleansetDriverjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setDriver", "(Ljava/lang/String;)Z" ) ;
-if (jbooleansetDriverjstringjava_lang_StringID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "setDriver");
-}
-
-jstring driver_ = curEnv->NewStringUTF( driver );
-if (driver != NULL && driver_ == NULL)
+bool Driver::setDriver (JavaVM * jvm_, char const* driver)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
-
-
-                        jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleansetDriverjstringjava_lang_StringID ,driver_));
-                        curEnv->DeleteLocalRef(driver_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-return (res == JNI_TRUE);
-
-}
 
-char* Driver::getDriver (JavaVM * jvm_){
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static jmethodID jbooleansetDriverjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setDriver", "(Ljava/lang/String;)Z" ) ;
+    if (jbooleansetDriverjstringjava_lang_StringID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "setDriver");
+    }
+
+    jstring driver_ = curEnv->NewStringUTF( driver );
+    if (driver != NULL && driver_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+
+    jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleansetDriverjstringjava_lang_StringID , driver_));
+    curEnv->DeleteLocalRef(driver_);
+    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() );
-
-jmethodID jstringgetDriverID = curEnv->GetStaticMethodID(cls, "getDriver", "()Ljava/lang/String;" ) ;
-if (jstringgetDriverID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "getDriver");
-}
-
-                        jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringgetDriverID ));
-                        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;
-}
-}
-
-void Driver::setPath (JavaVM * jvm_, char const* path){
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
+char* Driver::getDriver (JavaVM * jvm_)
+{
 
-jmethodID voidsetPathjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setPath", "(Ljava/lang/String;)V" ) ;
-if (voidsetPathjstringjava_lang_StringID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "setPath");
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static jmethodID jstringgetDriverID = curEnv->GetStaticMethodID(cls, "getDriver", "()Ljava/lang/String;" ) ;
+    if (jstringgetDriverID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "getDriver");
+    }
+
+    jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringgetDriverID ));
+    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);
+        if (curEnv->ExceptionCheck())
+        {
+            delete[] myStringBuffer;
+            throw GiwsException::JniCallMethodException(curEnv);
+        }
+        return myStringBuffer;
+    }
+    else
+    {
+        curEnv->DeleteLocalRef(res);
+        return NULL;
+    }
 }
 
-jstring path_ = curEnv->NewStringUTF( path );
-if (path != NULL && path_ == NULL)
+void Driver::setPath (JavaVM * jvm_, char const* path)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
-
-                         curEnv->CallStaticVoidMethod(cls, voidsetPathjstringjava_lang_StringID ,path_);
-                        curEnv->DeleteLocalRef(path_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static jmethodID voidsetPathjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setPath", "(Ljava/lang/String;)V" ) ;
+    if (voidsetPathjstringjava_lang_StringID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "setPath");
+    }
+
+    jstring path_ = curEnv->NewStringUTF( path );
+    if (path != NULL && path_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+
+    curEnv->CallStaticVoidMethod(cls, voidsetPathjstringjava_lang_StringID , path_);
+    curEnv->DeleteLocalRef(path_);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-char* Driver::end (JavaVM * jvm_, int uid){
-
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
-
-jmethodID jstringendjintintID = curEnv->GetStaticMethodID(cls, "end", "(I)Ljava/lang/String;" ) ;
-if (jstringendjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "end");
-}
+char* Driver::end (JavaVM * jvm_, int uid)
+{
 
-                        jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringendjintintID ,uid));
-                        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 = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static jmethodID jstringendjintintID = curEnv->GetStaticMethodID(cls, "end", "(I)Ljava/lang/String;" ) ;
+    if (jstringendjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "end");
+    }
+
+    jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringendjintintID , uid));
+    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);
+        if (curEnv->ExceptionCheck())
+        {
+            delete[] myStringBuffer;
+            throw GiwsException::JniCallMethodException(curEnv);
+        }
+        return myStringBuffer;
+    }
+    else
+    {
+        curEnv->DeleteLocalRef(res);
+        return NULL;
+    }
 }
 
 }
index b7bb4b9..74d8770 100644 (file)
@@ -1,5 +1,5 @@
-/* Generated by GIWS (version 2.0.1) with command:
-giws --disable-return-size-array --output-dir D:\git\debug\master\scilab\modules\graphic_export\src\jni\ --throws-exception-on-error --description-file Driver.giws.xml 
+/* Generated by GIWS (version 2.0.2) with command:
+giws --disable-return-size-array --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/Driver.giws.xml
 */
 /*
 
@@ -9,16 +9,16 @@ This software is a computer program whose purpose is to hide the complexity
 of accessing Java objects/methods from C++ code.
 
 This software is governed by the CeCILL-B license under French law and
-abiding by the rules of distribution of free software.  You can  use, 
+abiding by the rules of distribution of free software.  You can  use,
 modify and/ or redistribute the software under the terms of the CeCILL-B
 license as circulated by CEA, CNRS and INRIA at the following URL
-"http://www.cecill.info". 
+"http://www.cecill.info".
 
 As a counterpart to the access to the source code and  rights to copy,
 modify and redistribute granted by the license, users are provided only
 with a limited warranty  and the software's author,  the holder of the
 economic rights,  and the successive licensors  have only  limited
-liability. 
+liability.
 
 In this respect, the user's attention is drawn to the risks associated
 with loading,  using,  modifying and/or developing or reproducing the
@@ -27,9 +27,9 @@ that may mean  that it is complicated to manipulate,  and  that  also
 therefore means  that it is reserved for developers  and  experienced
 professionals having in-depth computer knowledge. Users are therefore
 encouraged to load and test the software's suitability as regards their
-requirements in conditions enabling the security of their systems and/or 
-data to be ensured and,  more generally, to use and operate it in the 
-same conditions as regards security. 
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
 
 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.
@@ -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,95 +69,119 @@ knowledge of the CeCILL-B license and that you accept its terms.
 # endif
 #endif
 
-namespace org_scilab_modules_graphic_export {
-class GIWSEXPORT Driver {
+namespace org_scilab_modules_graphic_export
+{
+class GIWSEXPORT Driver
+{
 
 private:
-JavaVM * jvm;
+    JavaVM * jvm;
 
 protected:
-jmethodID jbooleansetDriverjstringjava_lang_StringID; // cache method id
-jmethodID jstringgetDriverID; // cache method id
-jmethodID voidsetPathjstringjava_lang_StringID; // cache method id
-jmethodID jstringendjintintID; // cache method id
+    jmethodID jbooleansetDriverjstringjava_lang_StringID; // cache method id
+    jmethodID jstringgetDriverID; // cache method id
+    jmethodID voidsetPathjstringjava_lang_StringID; // cache method id
+    jmethodID jstringendjintintID; // 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
-*/
-Driver(JavaVM * jvm_);
+    // Constructor
+    /**
+    * Create a wrapping of the object from a JNIEnv.
+    * It will call the default constructor
+    * @param JEnv_ the Java Env
+    */
+    Driver(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
+    */
+    Driver(JavaVM * jvm_, jobject JObj);
+
+
+    /**
+    * This is a fake constructor to avoid the constructor
+    * chaining when dealing with extended giws classes
+    */
+#ifdef FAKEGIWSDATATYPE
+    Driver(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
+#endif
 
-/**
-* 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
-*/
-Driver(JavaVM * jvm_, jobject JObj);
+    // Destructor
+    ~Driver();
 
+    // 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
-Driver(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
-#endif
+    /**
+    * Exit monitor associated with the object.
+    * Equivalent of ending a "synchronized(obj)" scope.
+    */
+    void endSynchronize();
 
-// Destructor
-~Driver();
+    // Methods
+    static bool setDriver(JavaVM * jvm_, char const* driver);
 
-// Generic method
-// Synchronization methods
-/**
-* Enter monitor associated with the object.
-* Equivalent of creating a "synchronized(obj)" scope in Java.
-*/
-void synchronize();
+    static char* getDriver(JavaVM * jvm_);
 
-/**
-* Exit monitor associated with the object.
-* Equivalent of ending a "synchronized(obj)" scope.
-*/
-void endSynchronize();
+    static void setPath(JavaVM * jvm_, char const* path);
+
+    static char* end(JavaVM * jvm_, int uid);
+
+
+    /**
+    * 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/graphic_export/Driver";
+    }
 
-// Methods
-static bool setDriver(JavaVM * jvm_, char const* driver);
 
-static char* getDriver(JavaVM * jvm_);
+    /**
+    * Get class to use for static methods
+    * @return class to use for static methods
+    */
 
-static void setPath(JavaVM * jvm_, char const* path);
+    static jclass initClass(JNIEnv * curEnv)
+    {
+        static jclass cls = 0;
 
-static char* end(JavaVM * jvm_, int uid);
+        if (cls == 0)
+        {
+            jclass _cls = curEnv->FindClass(className().c_str());
+            if (_cls)
+            {
+                cls = static_cast<jclass>(curEnv->NewGlobalRef(_cls));
+            }
+        }
 
+        return cls;
+    }
 
-                        /**
-                        * 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/graphic_export/Driver";
-                }
-                
 };
 
 
index ce76758..2c6bd3c 100644 (file)
@@ -1,6 +1,6 @@
 #include "FileExporter.hxx"
-/* Generated by GIWS (version 2.0.1) with command:
-giws --disable-return-size-array --output-dir D:\git\debug\master\scilab\modules\graphic_export\src\jni\ --throws-exception-on-error --description-file FileExporter.giws.xml 
+/* Generated by GIWS (version 2.0.2) with command:
+giws --disable-return-size-array --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/FileExporter.giws.xml
 */
 /*
 
@@ -10,16 +10,16 @@ This software is a computer program whose purpose is to hide the complexity
 of accessing Java objects/methods from C++ code.
 
 This software is governed by the CeCILL-B license under French law and
-abiding by the rules of distribution of free software.  You can  use, 
+abiding by the rules of distribution of free software.  You can  use,
 modify and/ or redistribute the software under the terms of the CeCILL-B
 license as circulated by CEA, CNRS and INRIA at the following URL
-"http://www.cecill.info". 
+"http://www.cecill.info".
 
 As a counterpart to the access to the source code and  rights to copy,
 modify and redistribute granted by the license, users are provided only
 with a limited warranty  and the software's author,  the holder of the
 economic rights,  and the successive licensors  have only  limited
-liability. 
+liability.
 
 In this respect, the user's attention is drawn to the risks associated
 with loading,  using,  modifying and/or developing or reproducing the
@@ -28,164 +28,191 @@ that may mean  that it is complicated to manipulate,  and  that  also
 therefore means  that it is reserved for developers  and  experienced
 professionals having in-depth computer knowledge. Users are therefore
 encouraged to load and test the software's suitability as regards their
-requirements in conditions enabling the security of their systems and/or 
-data to be ensured and,  more generally, to use and operate it in the 
-same conditions as regards security. 
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
 
 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_graphic_export {
+namespace org_scilab_modules_graphic_export
+{
+
+// Static declarations (if any)
 
-                // Static declarations (if any)
-                
 // Returns the current env
 
-JNIEnv * FileExporter::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 * FileExporter::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
 
-FileExporter::~FileExporter() {
-JNIEnv * curEnv = NULL;
-this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-
-curEnv->DeleteGlobalRef(this->instance);
-curEnv->DeleteGlobalRef(this->instanceClass);
+FileExporter::~FileExporter()
+{
+    JNIEnv * curEnv = NULL;
+    this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    curEnv->DeleteGlobalRef(this->instance);
+    curEnv->DeleteGlobalRef(this->instanceClass);
 }
 // Constructors
-FileExporter::FileExporter(JavaVM * jvm_) {
-jmethodID constructObject = NULL ;
-jobject localInstance ;
-jclass localClass ;
+FileExporter::FileExporter(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());
-}
+    localClass = curEnv->FindClass( this->className().c_str() ) ;
+    if (localClass == NULL)
+    {
+        throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+    }
 
-this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
 
-/* localClass is not needed anymore */
-curEnv->DeleteLocalRef(localClass);
+    /* localClass is not needed anymore */
+    curEnv->DeleteLocalRef(localClass);
 
-if (this->instanceClass == NULL) {
-throw GiwsException::JniObjectCreationException(curEnv, this->className());
-}
+    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());
-}
+    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);
+    localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
+    if (localInstance == NULL)
+    {
+        throw GiwsException::JniObjectCreationException(curEnv, this->className());
+    }
 
-                /* Methods ID set to NULL */
-jstringfileExportjintintjstringjava_lang_StringjintintjfloatfloatjintintID=NULL;
+    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 */
+    jstringfileExportjintintjstringjava_lang_StringjintintjfloatfloatjintintID = NULL;
 
 
 }
 
-FileExporter::FileExporter(JavaVM * jvm_, jobject JObj) {
-        jvm=jvm_;
+FileExporter::FileExporter(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 */
-        jstringfileExportjintintjstringjava_lang_StringjintintjfloatfloatjintintID=NULL;
+    this->instance = curEnv->NewGlobalRef(JObj) ;
+    if (this->instance == NULL)
+    {
+        throw GiwsException::JniObjectCreationException(curEnv, this->className());
+    }
+    /* Methods ID set to NULL */
+    jstringfileExportjintintjstringjava_lang_StringjintintjfloatfloatjintintID = NULL;
 
 
 }
 
 // Generic methods
 
-void FileExporter::synchronize() {
-if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
-throw GiwsException::JniMonitorException(getCurrentEnv(), "FileExporter");
-}
+void FileExporter::synchronize()
+{
+    if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK)
+    {
+        throw GiwsException::JniMonitorException(getCurrentEnv(), "FileExporter");
+    }
 }
 
-void FileExporter::endSynchronize() {
-if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
-throw GiwsException::JniMonitorException(getCurrentEnv(), "FileExporter");
-}
+void FileExporter::endSynchronize()
+{
+    if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK)
+    {
+        throw GiwsException::JniMonitorException(getCurrentEnv(), "FileExporter");
+    }
 }
 // Method(s)
 
-char* FileExporter::fileExport (JavaVM * jvm_, int figureUID, char const* fileName, int fileType, float jpegCompressionQuality, int orientation){
-
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
-
-jmethodID jstringfileExportjintintjstringjava_lang_StringjintintjfloatfloatjintintID = curEnv->GetStaticMethodID(cls, "fileExport", "(ILjava/lang/String;IFI)Ljava/lang/String;" ) ;
-if (jstringfileExportjintintjstringjava_lang_StringjintintjfloatfloatjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "fileExport");
-}
-
-jstring fileName_ = curEnv->NewStringUTF( fileName );
-if (fileName != NULL && fileName_ == NULL)
+char* FileExporter::fileExport (JavaVM * jvm_, int figureUID, char const* fileName, int fileType, float jpegCompressionQuality, int orientation)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
-
 
-                        jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringfileExportjintintjstringjava_lang_StringjintintjfloatfloatjintintID ,figureUID, fileName_, fileType, jpegCompressionQuality, orientation));
-                        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(fileName_);
-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 = initClass(curEnv);
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    static jmethodID jstringfileExportjintintjstringjava_lang_StringjintintjfloatfloatjintintID = curEnv->GetStaticMethodID(cls, "fileExport", "(ILjava/lang/String;IFI)Ljava/lang/String;" ) ;
+    if (jstringfileExportjintintjstringjava_lang_StringjintintjfloatfloatjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "fileExport");
+    }
+
+    jstring fileName_ = curEnv->NewStringUTF( fileName );
+    if (fileName != NULL && fileName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+
+    jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringfileExportjintintjstringjava_lang_StringjintintjfloatfloatjintintID , figureUID, fileName_, fileType, jpegCompressionQuality, orientation));
+    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(fileName_);
+        if (curEnv->ExceptionCheck())
+        {
+            delete[] myStringBuffer;
+            throw GiwsException::JniCallMethodException(curEnv);
+        }
+        return myStringBuffer;
+    }
+    else
+    {
+        curEnv->DeleteLocalRef(res);
+        return NULL;
+    }
 }
 
 }
index 01d4cbb..b391198 100644 (file)
@@ -1,5 +1,5 @@
-/* Generated by GIWS (version 2.0.1) with command:
-giws --disable-return-size-array --output-dir D:\git\debug\master\scilab\modules\graphic_export\src\jni\ --throws-exception-on-error --description-file FileExporter.giws.xml 
+/* Generated by GIWS (version 2.0.2) with command:
+giws --disable-return-size-array --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/FileExporter.giws.xml
 */
 /*
 
@@ -9,16 +9,16 @@ This software is a computer program whose purpose is to hide the complexity
 of accessing Java objects/methods from C++ code.
 
 This software is governed by the CeCILL-B license under French law and
-abiding by the rules of distribution of free software.  You can  use, 
+abiding by the rules of distribution of free software.  You can  use,
 modify and/ or redistribute the software under the terms of the CeCILL-B
 license as circulated by CEA, CNRS and INRIA at the following URL
-"http://www.cecill.info". 
+"http://www.cecill.info".
 
 As a counterpart to the access to the source code and  rights to copy,
 modify and redistribute granted by the license, users are provided only
 with a limited warranty  and the software's author,  the holder of the
 economic rights,  and the successive licensors  have only  limited
-liability. 
+liability.
 
 In this respect, the user's attention is drawn to the risks associated
 with loading,  using,  modifying and/or developing or reproducing the
@@ -27,9 +27,9 @@ that may mean  that it is complicated to manipulate,  and  that  also
 therefore means  that it is reserved for developers  and  experienced
 professionals having in-depth computer knowledge. Users are therefore
 encouraged to load and test the software's suitability as regards their
-requirements in conditions enabling the security of their systems and/or 
-data to be ensured and,  more generally, to use and operate it in the 
-same conditions as regards security. 
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
 
 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.
@@ -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,86 +69,110 @@ knowledge of the CeCILL-B license and that you accept its terms.
 # endif
 #endif
 
-namespace org_scilab_modules_graphic_export {
-class GIWSEXPORT FileExporter {
+namespace org_scilab_modules_graphic_export
+{
+class GIWSEXPORT FileExporter
+{
 
 private:
-JavaVM * jvm;
+    JavaVM * jvm;
 
 protected:
-jmethodID jstringfileExportjintintjstringjava_lang_StringjintintjfloatfloatjintintID; // cache method id
+    jmethodID jstringfileExportjintintjstringjava_lang_StringjintintjfloatfloatjintintID; // 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
-*/
-FileExporter(JavaVM * jvm_);
+    // Constructor
+    /**
+    * Create a wrapping of the object from a JNIEnv.
+    * It will call the default constructor
+    * @param JEnv_ the Java Env
+    */
+    FileExporter(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
+    */
+    FileExporter(JavaVM * jvm_, jobject JObj);
+
+
+    /**
+    * This is a fake constructor to avoid the constructor
+    * chaining when dealing with extended giws classes
+    */
+#ifdef FAKEGIWSDATATYPE
+    FileExporter(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
+#endif
 
-/**
-* 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
-*/
-FileExporter(JavaVM * jvm_, jobject JObj);
+    // Destructor
+    ~FileExporter();
 
+    // 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
-FileExporter(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
-#endif
+    /**
+    * Exit monitor associated with the object.
+    * Equivalent of ending a "synchronized(obj)" scope.
+    */
+    void endSynchronize();
 
-// Destructor
-~FileExporter();
+    // Methods
+    static char* fileExport(JavaVM * jvm_, int figureUID, char const* fileName, int fileType, float jpegCompressionQuality, int orientation);
 
-// 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 char* fileExport(JavaVM * jvm_, int figureUID, char const* fileName, int fileType, float jpegCompressionQuality, int orientation);
-
-
-                        /**
-                        * 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/graphic_export/FileExporter";
-                }
-                
+    /**
+    * 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/graphic_export/FileExporter";
+    }
+
+
+    /**
+    * Get class to use for static methods
+    * @return class to use for static methods
+    */
+
+    static jclass initClass(JNIEnv * curEnv)
+    {
+        static jclass cls = 0;
+
+        if (cls == 0)
+        {
+            jclass _cls = curEnv->FindClass(className().c_str());
+            if (_cls)
+            {
+                cls = static_cast<jclass>(curEnv->NewGlobalRef(_cls));
+            }
+        }
+
+        return cls;
+    }
+
 };
 
 
index 6465985..c995100 100644 (file)
@@ -1,6 +1,6 @@
 #include "CallGraphicController.hxx"
-/* Generated by GIWS (version 2.0.1) with command:
-giws --disable-return-size-array --output-dir D:\git\debug\master\scilab\modules\graphic_objects\src\jni\ --throws-exception-on-error --description-file graphic_objects.giws.xml 
+/* Generated by GIWS (version 2.0.2) with command:
+giws --disable-return-size-array --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/graphic_objects.giws.xml
 */
 /*
 
@@ -10,16 +10,16 @@ This software is a computer program whose purpose is to hide the complexity
 of accessing Java objects/methods from C++ code.
 
 This software is governed by the CeCILL-B license under French law and
-abiding by the rules of distribution of free software.  You can  use, 
+abiding by the rules of distribution of free software.  You can  use,
 modify and/ or redistribute the software under the terms of the CeCILL-B
 license as circulated by CEA, CNRS and INRIA at the following URL
-"http://www.cecill.info". 
+"http://www.cecill.info".
 
 As a counterpart to the access to the source code and  rights to copy,
 modify and redistribute granted by the license, users are provided only
 with a limited warranty  and the software's author,  the holder of the
 economic rights,  and the successive licensors  have only  limited
-liability. 
+liability.
 
 In this respect, the user's attention is drawn to the risks associated
 with loading,  using,  modifying and/or developing or reproducing the
@@ -28,743 +28,922 @@ that may mean  that it is complicated to manipulate,  and  that  also
 therefore means  that it is reserved for developers  and  experienced
 professionals having in-depth computer knowledge. Users are therefore
 encouraged to load and test the software's suitability as regards their
-requirements in conditions enabling the security of their systems and/or 
-data to be ensured and,  more generally, to use and operate it in the 
-same conditions as regards security. 
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
 
 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_graphic_objects {
+namespace org_scilab_modules_graphic_objects
+{
+
+// Static declarations (if any)
 
-                // Static declarations (if any)
-                
 // Returns the current env
 
-JNIEnv * CallGraphicController::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 * CallGraphicController::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
 
-CallGraphicController::~CallGraphicController() {
-JNIEnv * curEnv = NULL;
-this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-
-curEnv->DeleteGlobalRef(this->instance);
-curEnv->DeleteGlobalRef(this->instanceClass);
-curEnv-&