Regenerate giws file from commit ac0e634c15ac035940e063401c3685bbaafab7c2. They were... 44/13144/2
Sylvestre Ledru [Wed, 13 Nov 2013 12:17:21 +0000 (13:17 +0100)]
Change-Id: I03c1b6b4eb6d0395f5adf2b5e9cc4a2764099608

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 9513543..124e2f7 100644 (file)
@@ -36,163 +36,142 @@ 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
-{
-
-// Static declarations (if any)
+namespace org_scilab_modules_action_binding_utils {
 
+                // 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 ;
-
-    const std::string construct = "<init>";
-    const std::string param = "()V";
-    jvm = jvm_;
+Signal::Signal(JavaVM * jvm_) {
+jmethodID constructObject = NULL ;
+jobject localInstance ;
+jclass localClass ;
 
-    JNIEnv * curEnv = getCurrentEnv();
+const std::string construct="<init>";
+const std::string param="()V";
+jvm=jvm_;
 
-    localClass = curEnv->FindClass( this->className().c_str() ) ;
-    if (localClass == NULL)
-    {
-        throw GiwsException::JniClassNotFoundException(curEnv, this->className());
-    }
+JNIEnv * curEnv = getCurrentEnv();
 
-    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+localClass = curEnv->FindClass( this->className().c_str() ) ;
+if (localClass == NULL) {
+  throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+}
 
-    /* localClass is not needed anymore */
-    curEnv->DeleteLocalRef(localClass);
+this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
 
-    if (this->instanceClass == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+/* localClass is not needed anymore */
+curEnv->DeleteLocalRef(localClass);
 
+if (this->instanceClass == NULL) {
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
-    if (constructObject == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
 
-    localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
-    if (localInstance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
+if(constructObject == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    this->instance = curEnv->NewGlobalRef(localInstance) ;
-    if (this->instance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-    /* localInstance not needed anymore */
-    curEnv->DeleteLocalRef(localInstance);
+localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
+if(localInstance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+this->instance = curEnv->NewGlobalRef(localInstance) ;
+if(this->instance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+/* localInstance not needed anymore */
+curEnv->DeleteLocalRef(localInstance);
 
-    /* Methods ID set to NULL */
-    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)
+void Signal::notify (JavaVM * jvm_, char const* ID){
+
+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);
+}
+
 
-    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);
-    }
+                         curEnv->CallStaticVoidMethod(cls, voidnotifyjstringjava_lang_StringID ,ID_);
+                        curEnv->DeleteLocalRef(ID_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 }
 
 }
index 8e50809..13f619f 100644 (file)
@@ -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,108 @@ typedef signed char byte;
 # 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_);
-
-    /**
-    * 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
-
-    // Destructor
-    ~Signal();
-
-    // 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";
-    }
+// 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);
 
-    /**
-    * Get class to use for static methods
-    * @return class to use for static methods
-    */
 
-    static jclass initClass(JNIEnv * curEnv)
-    {
-        static jclass cls = 0;
+/** 
+* This is a fake constructor to avoid the constructor
+* chaining when dealing with extended giws classes 
+*/
+#ifdef FAKEGIWSDATATYPE
+Signal(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
+#endif
 
-        if (cls == 0)
-        {
-            jclass _cls = curEnv->FindClass(className().c_str());
-            if (_cls)
-            {
-                cls = static_cast<jclass>(curEnv->NewGlobalRef(_cls));
-            }
-        }
+// Destructor
+~Signal();
 
-        return cls;
-    }
+// 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 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 d4c8fa1..4706533 100644 (file)
@@ -33,9 +33,8 @@ 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.
 */
 
-#include "GiwsException.hxx"
-namespace GiwsException
-{
+#include "GiwsException.hxx" 
+namespace GiwsException {
 
 
 
@@ -46,23 +45,23 @@ namespace GiwsException
 */
 JniException::JniException(JNIEnv * curEnv) throw() : exception()
 {
-    // retrieve information about the exception
-    javaException = curEnv->ExceptionOccurred();
-    /* Clear the Java Exception to avoid calling it again & again */
-    curEnv->ExceptionClear();
-    m_oJavaMessage = this->retrieveExceptionMessage(curEnv);
-    m_oJavaStackTrace = this->retrieveStackTrace(curEnv);
-    m_oJavaExceptionName = this->retrieveExceptionName(curEnv);
-
-    // by default JniExceptions display teh stack trace
-    setErrorMessage(m_oJavaMessage + "\n" + m_oJavaStackTrace);
-    curEnv->DeleteLocalRef(javaException);
-    closeException(curEnv);
+// retrieve information about the exception
+javaException = curEnv->ExceptionOccurred();
+/* Clear the Java Exception to avoid calling it again & again */
+curEnv->ExceptionClear();
+m_oJavaMessage = this->retrieveExceptionMessage(curEnv);
+m_oJavaStackTrace = this->retrieveStackTrace(curEnv);
+m_oJavaExceptionName = this->retrieveExceptionName(curEnv);
+
+// by default JniExceptions display teh stack trace
+setErrorMessage(m_oJavaMessage + "\n" + m_oJavaStackTrace);
+curEnv->DeleteLocalRef(javaException);
+closeException(curEnv);
 }
 
 JniException::~JniException(void) throw()
 {
-    m_oErrorMessage.clear();
+m_oErrorMessage.clear();
 }
 
 /**
@@ -71,7 +70,7 @@ JniException::~JniException(void) throw()
 */
 const char * JniException::what(void) const throw()
 {
-    return m_oErrorMessage.c_str();
+return m_oErrorMessage.c_str();
 }
 
 /**
@@ -79,7 +78,7 @@ const char * JniException::what(void) const throw()
 */
 std::string JniException::whatStr(void) const throw()
 {
-    return m_oErrorMessage;
+return m_oErrorMessage;
 }
 
 /**
@@ -87,7 +86,7 @@ std::string JniException::whatStr(void) const throw()
 */
 std::string JniException::getJavaDescription(void) const throw()
 {
-    return m_oJavaMessage;
+return m_oJavaMessage;
 }
 
 /**
@@ -95,7 +94,7 @@ std::string JniException::getJavaDescription(void) const throw()
 */
 std::string JniException::getJavaStackTrace(void) const throw()
 {
-    return m_oJavaStackTrace;
+return m_oJavaStackTrace;
 }
 
 /**
@@ -103,7 +102,7 @@ std::string JniException::getJavaStackTrace(void) const throw()
 */
 std::string JniException::getJavaExceptionName(void) const throw()
 {
-    return m_oJavaExceptionName;
+return m_oJavaExceptionName;
 }
 
 
@@ -112,7 +111,7 @@ std::string JniException::getJavaExceptionName(void) const throw()
 */
 void JniException::setErrorMessage(const std::string & errorMessage)
 {
-    m_oErrorMessage = errorMessage;
+m_oErrorMessage = errorMessage;
 }
 
 /**
@@ -120,7 +119,7 @@ void JniException::setErrorMessage(const std::string & errorMessage)
 */
 std::string JniException::getErrorMessage(void) const
 {
-    return m_oErrorMessage;
+return m_oErrorMessage;
 }
 
 /**
@@ -128,233 +127,233 @@ std::string JniException::getErrorMessage(void) const
 */
 std::string JniException::retrieveExceptionMessage(JNIEnv * curEnv)
 {
-    // return the result of the getLocalizedMessage method
-
-    // retrieve information from the exception.
-    // get method id
-    jmethodID getLocalizedMessageId = curEnv->GetMethodID(curEnv->GetObjectClass(javaException),
-                                      "getLocalizedMessage",
-                                      "()Ljava/lang/String;");
-
-    // call getLocalizedMessage
-    jstring description = (jstring) curEnv->CallObjectMethod(javaException, getLocalizedMessageId);
-
-    if (description == NULL)
-    {
-        return "";
-    }
+// return the result of the getLocalizedMessage method
 
-    std::string res = convertJavaString(curEnv, description);
+// retrieve information from the exception.
+// get method id
+jmethodID getLocalizedMessageId = curEnv->GetMethodID(curEnv->GetObjectClass(javaException),
+   "getLocalizedMessage",
+   "()Ljava/lang/String;");
 
-    // release java resources
-    curEnv->DeleteLocalRef(description);
+// call getLocalizedMessage
+jstring description = (jstring) curEnv->CallObjectMethod(javaException, getLocalizedMessageId);
 
-    return res;
-}
-
-/**
- * @return full stack trace when the exception occurred.
- */
-std::string JniException::retrieveStackTrace(JNIEnv * curEnv)
+if (description == NULL)
 {
-
-
-    // return the result of the getStackTrace method
-
-    // retrieve information from the exception.
-    // get method id
-    // getStackTrace returns an array of StackTraceElement
-    jmethodID getStackTraceId = curEnv->GetMethodID(curEnv->GetObjectClass(javaException),
-                                "getStackTrace",
-                                "()[Ljava/lang/StackTraceElement;");
-
-    // call getStackTrace
-    jobjectArray stackTrace = (jobjectArray) curEnv->CallObjectMethod(javaException, getStackTraceId);
-
-    if (stackTrace == NULL)
-    {
-        return "";
-    }
-
-    // get length of the array
-    jsize stackTraceLength = curEnv->GetArrayLength(stackTrace);
-    std::string res = "";
-
-    // get toString methodId of StackTraceElement class
-    jclass stackTraceElementClass = curEnv->FindClass("java/lang/StackTraceElement");
-    jmethodID toStringId = curEnv->GetMethodID(stackTraceElementClass, "toString", "()Ljava/lang/String;");
-
-    for (jsize i = 0; i < stackTraceLength; i++)
-    {
-        // add the result of toString method of each element in the result
-        jobject curStackTraceElement = curEnv->GetObjectArrayElement(stackTrace, i);
-
-        // call to string on the object
-        jstring stackElementString = (jstring) curEnv->CallObjectMethod(curStackTraceElement, toStringId);
-
-        if (stackElementString == NULL)
-        {
-            curEnv->DeleteLocalRef(stackTraceElementClass);
-            curEnv->DeleteLocalRef(stackTrace);
-            curEnv->DeleteLocalRef(curStackTraceElement);
-            return res;
-        }
-
-        // add a line to res
-        res += " at " + convertJavaString(curEnv, stackElementString) + "\n";
-
-        curEnv->DeleteLocalRef(curStackTraceElement);
-        curEnv->DeleteLocalRef(stackElementString);
-    }
-
-    // release java resources
-    curEnv->DeleteLocalRef(stackTraceElementClass);
-    curEnv->DeleteLocalRef(stackTrace);
-
-
-    return res;
+  return "";
 }
 
-/**
- * @return string containing the name of the exception (ie its class name).
- */
-std::string JniException::retrieveExceptionName(JNIEnv * curEnv)
-{
-
-    // then get its class
-    jclass exceptionClass = curEnv->GetObjectClass(javaException);
+std::string res = convertJavaString(curEnv, description);
 
-    // get the Class class
-    // we could also use curEnv->FindClass("Class");
-    jclass classClass = curEnv->GetObjectClass(exceptionClass);
+// release java resources
+curEnv->DeleteLocalRef(description);
 
-    // get the getName method
-    jmethodID getNameId = curEnv->GetMethodID(classClass, "getName", "()Ljava/lang/String;");
+return res;
+  }
 
-    // call the getName function
-    jstring javaName = (jstring) curEnv->CallObjectMethod(exceptionClass, getNameId);
+  /**
+   * @return full stack trace when the exception occurred.
+   */
+  std::string JniException::retrieveStackTrace(JNIEnv * curEnv)
+  {
 
-    if (javaName == NULL)
-    {
-        return "";
-    }
 
-    std::string res = convertJavaString(curEnv, javaName);
+// return the result of the getStackTrace method
 
-    // release java resources
-    curEnv->DeleteLocalRef(exceptionClass);
-    curEnv->DeleteLocalRef(classClass);
-    curEnv->DeleteLocalRef(javaName);
+// retrieve information from the exception.
+// get method id
+// getStackTrace returns an array of StackTraceElement
+jmethodID getStackTraceId = curEnv->GetMethodID(curEnv->GetObjectClass(javaException),
+"getStackTrace",
+"()[Ljava/lang/StackTraceElement;");
 
-    return res;
-}
+// call getStackTrace
+jobjectArray stackTrace = (jobjectArray) curEnv->CallObjectMethod(javaException, getStackTraceId);
 
-/**
- * To be called when all the information about the exceptions have been
- * retrived.
- * Remove the exception from the environment.
- */
-void JniException::closeException(JNIEnv * curEnv)
+if (stackTrace == NULL)
 {
-    // remove the exception from the environment
-    // Beware, the exception is no longer reachable
-    curEnv->ExceptionClear();
+  return "";
 }
 
-/**
- * Convert a Java string (jstring) into a C++ string
- */
-std::string JniException::convertJavaString(JNIEnv * curEnv, jstring javaString)
-{
-    // get a pointer on a C string
-    const char * tempString = curEnv->GetStringUTFChars(javaString, 0);
+// get length of the array
+jsize stackTraceLength = curEnv->GetArrayLength(stackTrace);
+std::string res = "";
 
-    // convert the C string into a C++ string
-    std::string res(tempString);
+// get toString methodId of StackTraceElement class
+jclass stackTraceElementClass = curEnv->FindClass("java/lang/StackTraceElement");
+jmethodID toStringId = curEnv->GetMethodID(stackTraceElementClass, "toString", "()Ljava/lang/String;");
 
-    // release pointer
-    curEnv->ReleaseStringUTFChars(javaString, tempString);
+for (jsize i = 0; i < stackTraceLength; i++)
+{
+  // add the result of toString method of each element in the result
+  jobject curStackTraceElement = curEnv->GetObjectArrayElement(stackTrace, i);
 
-    return res;
-}
+  // call to string on the object
+  jstring stackElementString = (jstring) curEnv->CallObjectMethod(curStackTraceElement, toStringId);
 
+  if (stackElementString == NULL)
+  {
+curEnv->DeleteLocalRef(stackTraceElementClass);
+curEnv->DeleteLocalRef(stackTrace);
+curEnv->DeleteLocalRef(curStackTraceElement);
+return res;
+  }
 
-/**
-* Exception that should be thrown when allocation of Java resources from C++
-* code fails (sur as NewDoubleArray or NewStringUTF).
-*/
+  // add a line to res
+  res += " at " + convertJavaString(curEnv, stackElementString) + "\n";
 
-JniBadAllocException::JniBadAllocException(JNIEnv * curEnv) throw() : JniException()
-{
-    std::string message = "Error no more memory.";
-    setErrorMessage(message);
+  curEnv->DeleteLocalRef(curStackTraceElement);
+  curEnv->DeleteLocalRef(stackElementString);
 }
 
-JniBadAllocException::~JniBadAllocException(void) throw() {}
+// release java resources
+curEnv->DeleteLocalRef(stackTraceElementClass);
+curEnv->DeleteLocalRef(stackTrace);
 
 
-/**
-* Exception that should be thrown when a call to a Java method
-* using Jni throw an exception.
-* If possible, user should try to avoid this sitution because of the loss
-* of information.
-*/
-
-/**
-* @param curEnv java environment where the exception occurred.
-*/
-JniCallMethodException::JniCallMethodException(JNIEnv * curEnv) throw() : JniException(curEnv)
-{
-    std::string errorMessage = "Exception when calling Java method : ";
-    errorMessage += getJavaDescription() + "\n" + getJavaStackTrace();
-    errorMessage += what();
-    setErrorMessage(errorMessage);
-}
-
-JniCallMethodException::~JniCallMethodException(void) throw() {}
-/**
-* @param className name of the class which haven't been found
-*/
-JniClassNotFoundException::JniClassNotFoundException(JNIEnv * curEnv, const std::string & className) throw() : JniException(curEnv)
-{
-    std::string errorMessage = "Could not get the Class " + className + ".";
-    setErrorMessage(errorMessage);
-}
+return res;
+  }
 
-JniClassNotFoundException::~JniClassNotFoundException(void) throw() {}
+  /**
+   * @return string containing the name of the exception (ie its class name).
+   */
+  std::string JniException::retrieveExceptionName(JNIEnv * curEnv)
+  {
 
-/**
- * @param className name of the method which haven't been found
- */
-JniMethodNotFoundException::JniMethodNotFoundException(JNIEnv * curEnv, const std::string & methodName) throw() : JniException(curEnv)
-{
-    std::string errorMessage = "Could not access to the method " + methodName + ".";
-    setErrorMessage(errorMessage);
-}
+// then get its class
+jclass exceptionClass = curEnv->GetObjectClass(javaException);
 
-JniMethodNotFoundException::~JniMethodNotFoundException(void) throw() {}
+// get the Class class
+// we could also use curEnv->FindClass("Class");
+jclass classClass = curEnv->GetObjectClass(exceptionClass);
 
-/**
- * @param curEnv java envirnonment where the exception occurred.
- */
-JniObjectCreationException::JniObjectCreationException(JNIEnv * curEnv, const std::string & className) throw() : JniException(curEnv)
-{
-    std::string errorMessage = "Could not instantiate the object " + className + ".";
-    setErrorMessage(errorMessage);
-}
+// get the getName method
+jmethodID getNameId = curEnv->GetMethodID(classClass, "getName", "()Ljava/lang/String;");
 
-JniObjectCreationException::~JniObjectCreationException(void) throw() {}
+// call the getName function
+jstring javaName = (jstring) curEnv->CallObjectMethod(exceptionClass, getNameId);
 
-/**
- * @param curEnv java envirnonment where the exception occurred.
- */
-JniMonitorException::JniMonitorException(JNIEnv * curEnv, const std::string & className) throw() : JniException(curEnv)
+if (javaName == NULL)
 {
-    std::string errorMessage = "Error in the access (Enter or exit) or a Java env monitor of class " + className + ".";
-    setErrorMessage(errorMessage);
+  return "";
 }
 
-JniMonitorException::~JniMonitorException(void) throw() {}
+std::string res = convertJavaString(curEnv, javaName);
+
+// release java resources
+curEnv->DeleteLocalRef(exceptionClass);
+curEnv->DeleteLocalRef(classClass);
+curEnv->DeleteLocalRef(javaName);
+
+return res;
+  }
+
+  /**
+   * To be called when all the information about the exceptions have been
+   * retrived.
+   * Remove the exception from the environment.
+   */
+  void JniException::closeException(JNIEnv * curEnv)
+  {
+// remove the exception from the environment
+// Beware, the exception is no longer reachable
+curEnv->ExceptionClear();
+  }
+
+  /**
+   * Convert a Java string (jstring) into a C++ string
+   */
+  std::string JniException::convertJavaString(JNIEnv * curEnv, jstring javaString)
+  {
+// get a pointer on a C string
+const char * tempString = curEnv->GetStringUTFChars(javaString, 0);
+
+// convert the C string into a C++ string
+std::string res(tempString);
+
+// release pointer
+curEnv->ReleaseStringUTFChars(javaString, tempString);
+
+return res;
+  }
+
+
+  /**
+  * Exception that should be thrown when allocation of Java resources from C++
+  * code fails (sur as NewDoubleArray or NewStringUTF).
+  */
+
+  JniBadAllocException::JniBadAllocException(JNIEnv * curEnv) throw() : JniException()
+  {
+  std::string message = "Error no more memory.";
+  setErrorMessage(message);
+  }
+
+  JniBadAllocException::~JniBadAllocException(void) throw() {}
+
+
+  /**
+  * Exception that should be thrown when a call to a Java method
+  * using Jni throw an exception.
+  * If possible, user should try to avoid this sitution because of the loss
+  * of information.
+  */
+
+  /**
+  * @param curEnv java environment where the exception occurred.
+  */
+  JniCallMethodException::JniCallMethodException(JNIEnv * curEnv) throw() : JniException(curEnv)
+  {
+  std::string errorMessage = "Exception when calling Java method : ";
+  errorMessage += getJavaDescription() + "\n" + getJavaStackTrace();
+  errorMessage += what();
+  setErrorMessage(errorMessage);
+  }
+
+  JniCallMethodException::~JniCallMethodException(void) throw() {}
+  /**
+  * @param className name of the class which haven't been found
+  */
+  JniClassNotFoundException::JniClassNotFoundException(JNIEnv * curEnv, const std::string & className) throw() : JniException(curEnv)
+  {
+std::string errorMessage = "Could not get the Class " + className + ".";
+setErrorMessage(errorMessage);
+  }
+
+  JniClassNotFoundException::~JniClassNotFoundException(void) throw() {}
+
+  /**
+   * @param className name of the method which haven't been found
+   */
+  JniMethodNotFoundException::JniMethodNotFoundException(JNIEnv * curEnv, const std::string & methodName) throw() : JniException(curEnv)
+  {
+std::string errorMessage = "Could not access to the method " + methodName + ".";
+setErrorMessage(errorMessage);
+  }
+
+  JniMethodNotFoundException::~JniMethodNotFoundException(void) throw() {}
+
+  /**
+   * @param curEnv java envirnonment where the exception occurred.
+   */
+  JniObjectCreationException::JniObjectCreationException(JNIEnv * curEnv, const std::string & className) throw() : JniException(curEnv)
+  {
+std::string errorMessage = "Could not instantiate the object " + className + ".";
+setErrorMessage(errorMessage);
+  }
+
+  JniObjectCreationException::~JniObjectCreationException(void) throw() {}
+
+  /**
+   * @param curEnv java envirnonment where the exception occurred.
+   */
+  JniMonitorException::JniMonitorException(JNIEnv * curEnv, const std::string & className) throw() : JniException(curEnv)
+  {
+std::string errorMessage = "Error in the access (Enter or exit) or a Java env monitor of class " + className + ".";
+setErrorMessage(errorMessage);
+  }
+
+  JniMonitorException::~JniMonitorException(void) throw() {}
 
 
 
index 3cb4e5f..4a8c1b4 100644 (file)
@@ -42,11 +42,11 @@ knowledge of the CeCILL-B license and that you accept its terms.
 #include <stdlib.h>
 #include <jni.h>
 
-#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
 #include <exception>
 
 
@@ -67,8 +67,7 @@ typedef signed char byte;
 #endif
 
 
-namespace GiwsException
-{
+namespace GiwsException {
 
 
 
@@ -78,99 +77,99 @@ namespace GiwsException
 class GIWSEXPORT JniException : public std::exception
 {
 
-    /** Error message to display */
-    std::string m_oErrorMessage;
+/** Error message to display */
+std::string m_oErrorMessage;
 
-    /** Java description of the exception*/
-    std::string m_oJavaMessage;
+/** Java description of the exception*/
+std::string m_oJavaMessage;
 
-    /** Java stackTrace when the exception occurred */
-    std::string m_oJavaStackTrace;
+/** Java stackTrace when the exception occurred */
+std::string m_oJavaStackTrace;
 
-    /** Name of the exception (ie class name).*/
-    std::string m_oJavaExceptionName;
+/** Name of the exception (ie class name).*/
+std::string m_oJavaExceptionName;
 
-    /** The exception itself ... we store as a member otherwise JNI
-    complains about 'WARNING in native method: JNI call made with
-    exception pending' */
-    jthrowable javaException;
+/** The exception itself ... we store as a member otherwise JNI
+complains about 'WARNING in native method: JNI call made with
+exception pending' */
+jthrowable javaException;
 
 public:
 
-    /**
-    * Each subclass of JniExcpetion should call the super constructor
-    * and the setErrorMessage function to set the message.
-    * @param curEnv java environment where the exception occurred.
-    */
-    JniException(JNIEnv * curEnv) throw() ;
-    JniException() throw() : exception() { };
+/**
+* Each subclass of JniExcpetion should call the super constructor
+* and the setErrorMessage function to set the message.
+* @param curEnv java environment where the exception occurred.
+*/
+JniException(JNIEnv * curEnv) throw() ;
+JniException() throw() : exception() { };
 
 
-    virtual ~JniException(void) throw();
+virtual ~JniException(void) throw();
 
-    /**
-    * @return a description of the exception
-    * @deprecated This function could lead to side effect error. Please use whatStr
-    */
-    virtual const char * what(void) const throw();
+/**
+* @return a description of the exception
+* @deprecated This function could lead to side effect error. Please use whatStr
+*/
+virtual const char * what(void) const throw();
 
-    /**
-    * @return a description of the exception
-    */
-    virtual std::string whatStr(void) const throw();
+/**
+* @return a description of the exception
+*/
+virtual std::string whatStr(void) const throw();
 
-    /**
-    * @return Java description of the exception.
-    */
-    std::string getJavaDescription(void) const throw();
+/**
+* @return Java description of the exception.
+*/
+std::string getJavaDescription(void) const throw();
 
-    /**
-    * @return Java stack trace where the exception occurred.
-    */
-    std::string getJavaStackTrace(void) const throw();
+/**
+* @return Java stack trace where the exception occurred.
+*/
+std::string getJavaStackTrace(void) const throw();
 
-    /**
-    * Get the name of the exception (ie its class name).
-    */
-    std::string getJavaExceptionName(void) const throw();
+/**
+* Get the name of the exception (ie its class name).
+*/
+std::string getJavaExceptionName(void) const throw();
 
 protected:
 
-    /**
-    * Set the error message that the exception should print.
-    */
-    void setErrorMessage(const std::string & errorMessage);
+/**
+* Set the error message that the exception should print.
+*/
+void setErrorMessage(const std::string & errorMessage);
 
-    /**
-    * Get the message that the exception will print.
-    */
-    std::string getErrorMessage(void) const;
+/**
+* Get the message that the exception will print.
+*/
+std::string getErrorMessage(void) const;
 
 private:
-    /**
-    * @return error message of the exception.
-    */
-    std::string retrieveExceptionMessage(JNIEnv * curEnv);
-    /**
-    * @return full stack trace when the exception occurred.
-    */
-    std::string retrieveStackTrace(JNIEnv * curEnv);
-
-    /**
-    * @return string containing the name of the exception (ie its class name).
-    */
-    std::string retrieveExceptionName(JNIEnv * curEnv);
-    /**
-    * To be called when all the information about the exceptions have been
-    * retrived.
-    * Remove the exception from the environment.
-    */
-    void closeException(JNIEnv * curEnv);
-
-    /**
-    * Convert a Java string (jstring) into a C++ string
-    */
-    std::string convertJavaString(JNIEnv * curEnv, jstring javaString);
+  /**
+* @return error message of the exception.
+*/
+std::string retrieveExceptionMessage(JNIEnv * curEnv);
+/**
+* @return full stack trace when the exception occurred.
+*/
+std::string retrieveStackTrace(JNIEnv * curEnv);
+
+/**
+* @return string containing the name of the exception (ie its class name).
+*/
+std::string retrieveExceptionName(JNIEnv * curEnv);
+/**
+* To be called when all the information about the exceptions have been
+* retrived.
+* Remove the exception from the environment.
+*/
+void closeException(JNIEnv * curEnv);
+
+/**
+* Convert a Java string (jstring) into a C++ string
+*/
+std::string convertJavaString(JNIEnv * curEnv, jstring javaString);
 };
 
 /**
@@ -181,8 +180,8 @@ class GIWSEXPORT JniBadAllocException : public JniException
 {
 public:
 
-    JniBadAllocException(JNIEnv * curEnv) throw();
-    virtual ~JniBadAllocException(void) throw();
+JniBadAllocException(JNIEnv * curEnv) throw();
+virtual ~JniBadAllocException(void) throw();
 };
 
 /**
@@ -195,12 +194,12 @@ class GIWSEXPORT JniCallMethodException : public JniException
 {
 public:
 
-    /**
-     * @param curEnv java envirnonment where the exception occurred.
-     */
-    JniCallMethodException(JNIEnv * curEnv) throw();
+  /**
+   * @param curEnv java envirnonment where the exception occurred.
+   */
+  JniCallMethodException(JNIEnv * curEnv) throw();
 
-    virtual ~JniCallMethodException(void) throw();
+  virtual ~JniCallMethodException(void) throw();
 };
 
 /**
@@ -210,12 +209,12 @@ class GIWSEXPORT JniClassNotFoundException : public JniException
 {
 public:
 
-    /**
-    * @param className name of the class which haven't been found
-    */
-    JniClassNotFoundException(JNIEnv * curEnv, const std::string & className) throw();
+/**
+* @param className name of the class which haven't been found
+*/
+JniClassNotFoundException(JNIEnv * curEnv, const std::string & className) throw();
 
-    virtual ~JniClassNotFoundException(void) throw();
+virtual ~JniClassNotFoundException(void) throw();
 
 };
 
@@ -226,11 +225,11 @@ class GIWSEXPORT JniMethodNotFoundException : public JniException
 {
 public:
 
-    /**
-    * @param className name of the method which haven't been found
-    */
-    JniMethodNotFoundException(JNIEnv * curEnv, const std::string & methodName) throw();
-    virtual ~JniMethodNotFoundException(void) throw();
+/**
+* @param className name of the method which haven't been found
+*/
+JniMethodNotFoundException(JNIEnv * curEnv, const std::string & methodName) throw();
+virtual ~JniMethodNotFoundException(void) throw();
 
 };
 
@@ -244,11 +243,11 @@ class GIWSEXPORT JniObjectCreationException : public JniException
 {
 public:
 
-    /**
-    * @param curEnv java envirnonment where the exception occurred.
-    */
-    JniObjectCreationException(JNIEnv * curEnv, const std::string & className) throw();
-    virtual ~JniObjectCreationException(void) throw();
+/**
+* @param curEnv java envirnonment where the exception occurred.
+*/
+JniObjectCreationException(JNIEnv * curEnv, const std::string & className) throw();
+virtual ~JniObjectCreationException(void) throw();
 
 };
 
@@ -261,11 +260,11 @@ class GIWSEXPORT JniMonitorException : public JniException
 {
 public:
 
-    /**
-    * @param curEnv java envirnonment where the exception occurred.
-    */
-    JniMonitorException(JNIEnv * curEnv, const std::string & className) throw();
-    virtual ~JniMonitorException(void) throw();
+/**
+* @param curEnv java envirnonment where the exception occurred.
+*/
+JniMonitorException(JNIEnv * curEnv, const std::string & className) throw();
+virtual ~JniMonitorException(void) throw();
 
 };
 
index d1cb164..dded9f0 100644 (file)
@@ -36,410 +36,352 @@ 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
-{
-
-// Static declarations (if any)
+namespace org_scilab_modules_gui_bridge {
 
+                // 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());
-    }
-
-    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+localClass = curEnv->FindClass( this->className().c_str() ) ;
+if (localClass == NULL) {
+  throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+}
 
-    /* localClass is not needed anymore */
-    curEnv->DeleteLocalRef(localClass);
+this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
 
-    if (this->instanceClass == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+/* localClass is not needed anymore */
+curEnv->DeleteLocalRef(localClass);
 
+if (this->instanceClass == NULL) {
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
-    if (constructObject == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
 
-    localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
-    if (localInstance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
+if(constructObject == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    this->instance = curEnv->NewGlobalRef(localInstance) ;
-    if (this->instance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-    /* localInstance not needed anymore */
-    curEnv->DeleteLocalRef(localInstance);
+localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
+if(localInstance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+this->instance = curEnv->NewGlobalRef(localInstance) ;
+if(this->instance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+/* localInstance not needed anymore */
+curEnv->DeleteLocalRef(localInstance);
 
-    /* Methods ID set to NULL */
-    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)
+void CallScilabBridge::display (JavaVM * jvm_, char const* dataToDisplay){
+
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+
+static 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)
 {
+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, voiddisplayjstringjava_lang_StringID ,dataToDisplay_);
+                        curEnv->DeleteLocalRef(dataToDisplay_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+}
 
-    static jmethodID voiddisplayjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "display", "(Ljava/lang/String;)V" ) ;
-    if (voiddisplayjstringjava_lang_StringID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "display");
-    }
+char* CallScilabBridge::readLine (JavaVM * jvm_){
 
-    jstring dataToDisplay_ = curEnv->NewStringUTF( dataToDisplay );
-    if (dataToDisplay != NULL && dataToDisplay_ == NULL)
-    {
-        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 jstringreadLineID = curEnv->GetStaticMethodID(cls, "readLine", "()Ljava/lang/String;" ) ;
+if (jstringreadLineID == NULL) {
 
-    curEnv->CallStaticVoidMethod(cls, voiddisplayjstringjava_lang_StringID , dataToDisplay_);
-    curEnv->DeleteLocalRef(dataToDisplay_);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+jvm_->DetachCurrentThread();
+throw GiwsException::JniMethodNotFoundException(curEnv, "readLine");
 }
 
-char* CallScilabBridge::readLine (JavaVM * jvm_)
-{
+                        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();
 
-    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();
+return myStringBuffer;
+ } else { 
+curEnv->DeleteLocalRef(res);
+return NULL;
+}
+}
 
-        return myStringBuffer;
-    }
-    else
-    {
-        curEnv->DeleteLocalRef(res);
-        return NULL;
-    }
+void CallScilabBridge::clear (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::clear (JavaVM * jvm_)
-{
+static jmethodID voidclearID = curEnv->GetStaticMethodID(cls, "clear", "()V" ) ;
+if (voidclearID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "clear");
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+                         curEnv->CallStaticVoidMethod(cls, voidclearID );
+                        if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+}
 
-    static jmethodID voidclearID = curEnv->GetStaticMethodID(cls, "clear", "()V" ) ;
-    if (voidclearID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "clear");
-    }
+void CallScilabBridge::clear (JavaVM * jvm_, int nbLines){
 
-    curEnv->CallStaticVoidMethod(cls, voidclearID );
-    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);
 }
 
-void CallScilabBridge::clear (JavaVM * jvm_, int nbLines)
-{
+static jmethodID voidclearjintintID = curEnv->GetStaticMethodID(cls, "clear", "(I)V" ) ;
+if (voidclearjintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "clear");
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+                         curEnv->CallStaticVoidMethod(cls, voidclearjintintID ,nbLines);
+                        if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+}
 
-    static jmethodID voidclearjintintID = curEnv->GetStaticMethodID(cls, "clear", "(I)V" ) ;
-    if (voidclearjintintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "clear");
-    }
+int CallScilabBridge::getCharWithoutOutput (JavaVM * jvm_){
 
-    curEnv->CallStaticVoidMethod(cls, voidclearjintintID , nbLines);
-    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);
 }
 
-int CallScilabBridge::getCharWithoutOutput (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 = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetCharWithoutOutputID ));
+                        if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    static jmethodID jintgetCharWithoutOutputID = curEnv->GetStaticMethodID(cls, "getCharWithoutOutput", "()I" ) ;
-    if (jintgetCharWithoutOutputID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "getCharWithoutOutput");
-    }
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetCharWithoutOutputID ));
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+void CallScilabBridge::toHome (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 voidtoHomeID = curEnv->GetStaticMethodID(cls, "toHome", "()V" ) ;
+if (voidtoHomeID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "toHome");
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+                         curEnv->CallStaticVoidMethod(cls, voidtoHomeID );
+                        if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+}
 
-    static jmethodID voidtoHomeID = curEnv->GetStaticMethodID(cls, "toHome", "()V" ) ;
-    if (voidtoHomeID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "toHome");
-    }
+void CallScilabBridge::scilabLinesUpdate (JavaVM * jvm_){
 
-    curEnv->CallStaticVoidMethod(cls, voidtoHomeID );
-    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);
 }
 
-void CallScilabBridge::scilabLinesUpdate (JavaVM * jvm_)
-{
+static jmethodID voidscilabLinesUpdateID = curEnv->GetStaticMethodID(cls, "scilabLinesUpdate", "()V" ) ;
+if (voidscilabLinesUpdateID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "scilabLinesUpdate");
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+                         curEnv->CallStaticVoidMethod(cls, voidscilabLinesUpdateID );
+                        if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+}
 
-    static jmethodID voidscilabLinesUpdateID = curEnv->GetStaticMethodID(cls, "scilabLinesUpdate", "()V" ) ;
-    if (voidscilabLinesUpdateID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "scilabLinesUpdate");
-    }
+void CallScilabBridge::setPrompt (JavaVM * jvm_, char const* promptToSet){
 
-    curEnv->CallStaticVoidMethod(cls, voidscilabLinesUpdateID );
-    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);
 }
 
-void CallScilabBridge::setPrompt (JavaVM * jvm_, char const* promptToSet)
-{
+static jmethodID voidsetPromptjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setPrompt", "(Ljava/lang/String;)V" ) ;
+if (voidsetPromptjstringjava_lang_StringID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "setPrompt");
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+jstring promptToSet_ = curEnv->NewStringUTF( promptToSet );
+if (promptToSet != NULL && promptToSet_ == NULL)
+{
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    static jmethodID voidsetPromptjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "setPrompt", "(Ljava/lang/String;)V" ) ;
-    if (voidsetPromptjstringjava_lang_StringID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "setPrompt");
-    }
 
-    jstring promptToSet_ = curEnv->NewStringUTF( promptToSet );
-    if (promptToSet != NULL && promptToSet_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+                         curEnv->CallStaticVoidMethod(cls, voidsetPromptjstringjava_lang_StringID ,promptToSet_);
+                        curEnv->DeleteLocalRef(promptToSet_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+}
 
+bool CallScilabBridge::isWaitingForInput (JavaVM * jvm_){
 
-    curEnv->CallStaticVoidMethod(cls, voidsetPromptjstringjava_lang_StringID , promptToSet_);
-    curEnv->DeleteLocalRef(promptToSet_);
-    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);
 }
 
-bool CallScilabBridge::isWaitingForInput (JavaVM * jvm_)
-{
+static jmethodID jbooleanisWaitingForInputID = curEnv->GetStaticMethodID(cls, "isWaitingForInput", "()Z" ) ;
+if (jbooleanisWaitingForInputID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "isWaitingForInput");
+}
 
-    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);
+                        jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanisWaitingForInputID ));
+                        if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return (res == JNI_TRUE);
 
 }
 
index a36594d..f9895bc 100644 (file)
@@ -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,134 +69,132 @@ typedef signed char byte;
 # 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_);
-
-    /**
-    * 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
-
-    // Destructor
-    ~CallScilabBridge();
+// Constructor
+/**
+* Create a wrapping of the object from a JNIEnv.
+* It will call the default constructor
+* @param JEnv_ the Java Env
+*/
+CallScilabBridge(JavaVM * jvm_);
 
-    // Generic method
-    // Synchronization methods
-    /**
-    * Enter monitor associated with the object.
-    * Equivalent of creating a "synchronized(obj)" scope in Java.
-    */
-    void synchronize();
+/**
+* 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);
 
-    /**
-    * Exit monitor associated with the object.
-    * Equivalent of ending a "synchronized(obj)" scope.
-    */
-    void endSynchronize();
 
-    // Methods
-    static void display(JavaVM * jvm_, char const* dataToDisplay);
+/** 
+* This is a fake constructor to avoid the constructor
+* chaining when dealing with extended giws classes 
+*/
+#ifdef FAKEGIWSDATATYPE
+CallScilabBridge(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
+#endif
 
-    static char* readLine(JavaVM * jvm_);
+// Destructor
+~CallScilabBridge();
 
-    static void clear(JavaVM * jvm_);
+// Generic method
+// Synchronization methods
+/**
+* Enter monitor associated with the object.
+* Equivalent of creating a "synchronized(obj)" scope in Java.
+*/
+void synchronize();
 
-    static void clear(JavaVM * jvm_, int nbLines);
+/**
+* Exit monitor associated with the object.
+* Equivalent of ending a "synchronized(obj)" scope.
+*/
+void endSynchronize();
 
-    static int getCharWithoutOutput(JavaVM * jvm_);
+// Methods
+static void display(JavaVM * jvm_, char const* dataToDisplay);
 
-    static void toHome(JavaVM * jvm_);
+static char* readLine(JavaVM * jvm_);
 
-    static void scilabLinesUpdate(JavaVM * jvm_);
+static void clear(JavaVM * jvm_);
 
-    static void setPrompt(JavaVM * jvm_, char const* promptToSet);
+static void clear(JavaVM * jvm_, int nbLines);
 
-    static bool isWaitingForInput(JavaVM * jvm_);
+static int getCharWithoutOutput(JavaVM * jvm_);
 
+static void toHome(JavaVM * jvm_);
 
-    /**
-    * Get class name to use for static methods
-    * @return class name to use for static methods
-    */
+static void scilabLinesUpdate(JavaVM * jvm_);
 
-    static const std::string className()
-    {
-        return "org/scilab/modules/gui/bridge/CallScilabBridge";
-    }
+static void setPrompt(JavaVM * jvm_, char const* promptToSet);
 
+static bool isWaitingForInput(JavaVM * jvm_);
 
-    /**
-    * Get class to use for static methods
-    * @return class to use for static methods
-    */
 
-    static jclass initClass(JNIEnv * curEnv)
-    {
-        static jclass cls = 0;
+                        /**
+                        * 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";
+                }
+                
 
-        if (cls == 0)
-        {
-            jclass _cls = curEnv->FindClass(className().c_str());
-            if (_cls)
-            {
-                cls = static_cast<jclass>(curEnv->NewGlobalRef(_cls));
-            }
-        }
+                        /**
+                        * Get class to use for static methods
+                        * @return class to use for static methods
+                        */
+                        
+                static jclass initClass(JNIEnv * curEnv)
+                {
+                    static jclass cls = 0;
 
-        return cls;
-    }
+                    if (cls == 0)
+                    {
+                        jclass _cls = curEnv->FindClass(className().c_str());
+                        if (_cls)
+                        {
+                            cls = static_cast<jclass>(curEnv->NewGlobalRef(_cls));
+                        }
+                    }
 
+                    return cls;
+                 }
+                
 };
 
 
index 2b06dcd..c29c1a8 100644 (file)
@@ -36,166 +36,145 @@ The fact that you are presently reading this means that you have had
 knowledge of the CeCILL-B license and that you accept its terms.
 */
 
-namespace org_scilab_modules_external_objects_java
-{
-
-// Static declarations (if any)
+namespace org_scilab_modules_external_objects_java {
 
+                // Static declarations (if any)
+                
 // Returns the current env
 
-JNIEnv * 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 ;
-
-    const std::string construct = "<init>";
-    const std::string param = "()V";
-    jvm = jvm_;
+ScilabClassLoader::ScilabClassLoader(JavaVM * jvm_) {
+jmethodID constructObject = NULL ;
+jobject localInstance ;
+jclass localClass ;
 
-    JNIEnv * curEnv = getCurrentEnv();
+const std::string construct="<init>";
+const std::string param="()V";
+jvm=jvm_;
 
-    localClass = curEnv->FindClass( this->className().c_str() ) ;
-    if (localClass == NULL)
-    {
-        throw GiwsException::JniClassNotFoundException(curEnv, this->className());
-    }
+JNIEnv * curEnv = getCurrentEnv();
 
-    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+localClass = curEnv->FindClass( this->className().c_str() ) ;
+if (localClass == NULL) {
+  throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+}
 
-    /* localClass is not needed anymore */
-    curEnv->DeleteLocalRef(localClass);
+this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
 
-    if (this->instanceClass == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+/* localClass is not needed anymore */
+curEnv->DeleteLocalRef(localClass);
 
+if (this->instanceClass == NULL) {
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
-    if (constructObject == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
 
-    localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
-    if (localInstance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
+if(constructObject == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    this->instance = curEnv->NewGlobalRef(localInstance) ;
-    if (this->instance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-    /* localInstance not needed anymore */
-    curEnv->DeleteLocalRef(localInstance);
+localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
+if(localInstance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+this->instance = curEnv->NewGlobalRef(localInstance) ;
+if(this->instance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+/* localInstance not needed anymore */
+curEnv->DeleteLocalRef(localInstance);
 
-    /* Methods ID set to NULL */
-    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)
+int ScilabClassLoader::loadJavaClass (JavaVM * jvm_, char const* name, bool allowReload){
+
+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);
+}
 
-    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;
+
+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 9fe2afc..21e9bd9 100644 (file)
@@ -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,108 @@ typedef signed char byte;
 # 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_);
-
-    /**
-    * 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
-
-    // Destructor
-    ~ScilabClassLoader();
-
-    // 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";
-    }
+// 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);
 
-    /**
-    * Get class to use for static methods
-    * @return class to use for static methods
-    */
 
-    static jclass initClass(JNIEnv * curEnv)
-    {
-        static jclass cls = 0;
+/** 
+* This is a fake constructor to avoid the constructor
+* chaining when dealing with extended giws classes 
+*/
+#ifdef FAKEGIWSDATATYPE
+ScilabClassLoader(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
+#endif
 
-        if (cls == 0)
-        {
-            jclass _cls = curEnv->FindClass(className().c_str());
-            if (_cls)
-            {
-                cls = static_cast<jclass>(curEnv->NewGlobalRef(_cls));
-            }
-        }
+// Destructor
+~ScilabClassLoader();
 
-        return cls;
-    }
+// 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 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 08cfc5c..06e81b4 100644 (file)
@@ -36,207 +36,185 @@ The fact that you are presently reading this means that you have had
 knowledge of the CeCILL-B license and that you accept its terms.
 */
 
-namespace org_scilab_modules_external_objects_java
-{
-
-// Static declarations (if any)
+namespace org_scilab_modules_external_objects_java {
 
+                // Static declarations (if any)
+                
 // Returns the current env
 
-JNIEnv * ScilabJarCreator::getCurrentEnv()
-{
-    JNIEnv * curEnv = NULL;
-    jint res = this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    if (res != JNI_OK)
-    {
-        throw GiwsException::JniException(getCurrentEnv());
-    }
-    return curEnv;
+JNIEnv * ScilabJarCreator::getCurrentEnv() {
+JNIEnv * curEnv = NULL;
+jint res=this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+if (res != JNI_OK) {
+throw GiwsException::JniException(getCurrentEnv());
+}
+return curEnv;
 }
 // Destructor
 
-ScilabJarCreator::~ScilabJarCreator()
-{
-    JNIEnv * curEnv = NULL;
-    this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    curEnv->DeleteGlobalRef(this->instance);
-    curEnv->DeleteGlobalRef(this->instanceClass);
-    curEnv->DeleteGlobalRef(this->stringArrayClass);
-}
+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_;
+ScilabJarCreator::ScilabJarCreator(JavaVM * jvm_) {
+jmethodID constructObject = NULL ;
+jobject localInstance ;
+jclass localClass ;
 
-    JNIEnv * curEnv = getCurrentEnv();
+const std::string construct="<init>";
+const std::string param="()V";
+jvm=jvm_;
 
-    localClass = curEnv->FindClass( this->className().c_str() ) ;
-    if (localClass == NULL)
-    {
-        throw GiwsException::JniClassNotFoundException(curEnv, this->className());
-    }
+JNIEnv * curEnv = getCurrentEnv();
 
-    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+localClass = curEnv->FindClass( this->className().c_str() ) ;
+if (localClass == NULL) {
+  throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+}
 
-    /* localClass is not needed anymore */
-    curEnv->DeleteLocalRef(localClass);
+this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
 
-    if (this->instanceClass == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+/* localClass is not needed anymore */
+curEnv->DeleteLocalRef(localClass);
 
+if (this->instanceClass == NULL) {
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
-    if (constructObject == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
 
-    localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
-    if (localInstance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
+if(constructObject == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    this->instance = curEnv->NewGlobalRef(localInstance) ;
-    if (this->instance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-    /* localInstance not needed anymore */
-    curEnv->DeleteLocalRef(localInstance);
+localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
+if(localInstance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+this->instance = curEnv->NewGlobalRef(localInstance) ;
+if(this->instance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+/* localInstance not needed anymore */
+curEnv->DeleteLocalRef(localInstance);
 
-    /* Methods ID set to NULL */
-    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;
 
 
 }
 
-ScilabJarCreator::ScilabJarCreator(JavaVM * jvm_, jobject JObj)
-{
-    jvm = jvm_;
+ScilabJarCreator::ScilabJarCreator(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 */
-    jintcreateJarArchivejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID = NULL;
+        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;
 
 
 }
 
 // Generic methods
 
-void ScilabJarCreator::synchronize()
+void ScilabJarCreator::synchronize() {
+if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
+throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJarCreator");
+}
+}
+
+void ScilabJarCreator::endSynchronize() {
+if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
+throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJarCreator");
+}
+}
+// Method(s)
+
+int ScilabJarCreator::createJarArchive (JavaVM * jvm_, char const* jarFilePath, char const* const* filePaths, int filePathsSize, char const* filesRootPath, char const* manifestFilePath, bool keepAbsolutePaths){
+
+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)
 {
-    if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK)
-    {
-        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJarCreator");
-    }
+throw GiwsException::JniBadAllocException(curEnv);
 }
 
-void ScilabJarCreator::endSynchronize()
+jclass stringArrayClass = curEnv->FindClass("java/lang/String");
+
+// create java array of strings.
+jobjectArray filePaths_ = curEnv->NewObjectArray( filePathsSize, stringArrayClass, NULL);
+if (filePaths_ == NULL)
 {
-    if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK)
-    {
-        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJarCreator");
-    }
+throw GiwsException::JniBadAllocException(curEnv);
 }
-// Method(s)
 
-int ScilabJarCreator::createJarArchive (JavaVM * jvm_, char const* jarFilePath, char const* const* filePaths, int filePathsSize, char const* filesRootPath, char const* manifestFilePath, bool keepAbsolutePaths)
+// 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);
+}
 
-    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);
-        }
+curEnv->SetObjectArrayElement( filePaths_, i, TempString);
 
-        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;
+// 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 05d90d0..576d0bf 100644 (file)
@@ -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,111 +69,109 @@ typedef signed char byte;
 # endif
 #endif
 
-namespace org_scilab_modules_external_objects_java
-{
-class GIWSEXPORT ScilabJarCreator
-{
+namespace org_scilab_modules_external_objects_java {
+class GIWSEXPORT ScilabJarCreator {
 
 private:
-    JavaVM * jvm;
+JavaVM * jvm;
 
 protected:
-    jmethodID jintcreateJarArchivejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID; // cache method id
-    jclass stringArrayClass;
-
+jmethodID jintcreateJarArchivejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID; // cache method id
+jclass stringArrayClass;
 
 
-    jobject instance;
-    jclass instanceClass; // cache class
 
+jobject instance;
+jclass instanceClass; // cache class
 
-    // Caching (if any)
+                       
+// Caching (if any)
 
 
-    /**
-    * Get the environment matching to the current thread.
-    */
-    virtual JNIEnv * getCurrentEnv();
+/**
+* Get the environment matching to the current thread.
+*/
+virtual JNIEnv * getCurrentEnv();
 
 public:
-    // Constructor
-    /**
-    * Create a wrapping of the object from a JNIEnv.
-    * It will call the default constructor
-    * @param JEnv_ the Java Env
-    */
-    ScilabJarCreator(JavaVM * jvm_);
-
-    /**
-    * Create a wrapping of an already existing object from a JNIEnv.
-    * The object must have already been instantiated
-    * @param JEnv_ the Java Env
-    * @param JObj the object
-    */
-    ScilabJarCreator(JavaVM * jvm_, jobject JObj);
-
-
-    /**
-    * This is a fake constructor to avoid the constructor
-    * chaining when dealing with extended giws classes
-    */
-#ifdef FAKEGIWSDATATYPE
-    ScilabJarCreator(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
-#endif
-
-    // Destructor
-    ~ScilabJarCreator();
-
-    // Generic method
-    // Synchronization methods
-    /**
-    * Enter monitor associated with the object.
-    * Equivalent of creating a "synchronized(obj)" scope in Java.
-    */
-    void synchronize();
-
-    /**
-    * 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";
-    }
+// 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);
 
-    /**
-    * Get class to use for static methods
-    * @return class to use for static methods
-    */
 
-    static jclass initClass(JNIEnv * curEnv)
-    {
-        static jclass cls = 0;
+/** 
+* This is a fake constructor to avoid the constructor
+* chaining when dealing with extended giws classes 
+*/
+#ifdef FAKEGIWSDATATYPE
+ScilabJarCreator(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
+#endif
 
-        if (cls == 0)
-        {
-            jclass _cls = curEnv->FindClass(className().c_str());
-            if (_cls)
-            {
-                cls = static_cast<jclass>(curEnv->NewGlobalRef(_cls));
-            }
-        }
+// Destructor
+~ScilabJarCreator();
 
-        return cls;
-    }
+// 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 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 9dd0e61..08a7db5 100644 (file)
@@ -36,176 +36,155 @@ The fact that you are presently reading this means that you have had
 knowledge of the CeCILL-B license and that you accept its terms.
 */
 
-namespace org_scilab_modules_external_objects_java
-{
-
-// Static declarations (if any)
+namespace org_scilab_modules_external_objects_java {
 
+                // Static declarations (if any)
+                
 // Returns the current env
 
-JNIEnv * 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());
-    }
-
-    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+localClass = curEnv->FindClass( this->className().c_str() ) ;
+if (localClass == NULL) {
+  throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+}
 
-    /* localClass is not needed anymore */
-    curEnv->DeleteLocalRef(localClass);
+this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
 
-    if (this->instanceClass == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+/* localClass is not needed anymore */
+curEnv->DeleteLocalRef(localClass);
 
+if (this->instanceClass == NULL) {
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
-    if (constructObject == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
 
-    localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
-    if (localInstance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
+if(constructObject == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    this->instance = curEnv->NewGlobalRef(localInstance) ;
-    if (this->instance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-    /* localInstance not needed anymore */
-    curEnv->DeleteLocalRef(localInstance);
+localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
+if(localInstance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+this->instance = curEnv->NewGlobalRef(localInstance) ;
+if(this->instance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+/* localInstance not needed anymore */
+curEnv->DeleteLocalRef(localInstance);
 
-    /* Methods ID set to NULL */
-    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::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");
-    }
+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)
+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 = 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);
+}
+
 
-    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;
+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 053ef3c..cf7c819 100644 (file)
@@ -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,108 @@ typedef signed char byte;
 # 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_);
-
-    /**
-    * 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
-
-    // Destructor
-    ~ScilabJavaArray();
-
-    // 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";
-    }
+// 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);
 
-    /**
-    * Get class to use for static methods
-    * @return class to use for static methods
-    */
 
-    static jclass initClass(JNIEnv * curEnv)
-    {
-        static jclass cls = 0;
+/** 
+* This is a fake constructor to avoid the constructor
+* chaining when dealing with extended giws classes 
+*/
+#ifdef FAKEGIWSDATATYPE
+ScilabJavaArray(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
+#endif
 
-        if (cls == 0)
-        {
-            jclass _cls = curEnv->FindClass(className().c_str());
-            if (_cls)
-            {
-                cls = static_cast<jclass>(curEnv->NewGlobalRef(_cls));
-            }
-        }
+// Destructor
+~ScilabJavaArray();
 
-        return cls;
-    }
+// 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 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 fca8af2..59f7eb7 100644 (file)
@@ -36,168 +36,147 @@ The fact that you are presently reading this means that you have had
 knowledge of the CeCILL-B license and that you accept its terms.
 */
 
-namespace org_scilab_modules_external_objects_java
-{
-
-// Static declarations (if any)
+namespace org_scilab_modules_external_objects_java {
 
+                // Static declarations (if any)
+                
 // Returns the current env
 
-JNIEnv * 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 ;
-
-    const std::string construct = "<init>";
-    const std::string param = "()V";
-    jvm = jvm_;
+ScilabJavaClass::ScilabJavaClass(JavaVM * jvm_) {
+jmethodID constructObject = NULL ;
+jobject localInstance ;
+jclass localClass ;
 
-    JNIEnv * curEnv = getCurrentEnv();
+const std::string construct="<init>";
+const std::string param="()V";
+jvm=jvm_;
 
-    localClass = curEnv->FindClass( this->className().c_str() ) ;
-    if (localClass == NULL)
-    {
-        throw GiwsException::JniClassNotFoundException(curEnv, this->className());
-    }
+JNIEnv * curEnv = getCurrentEnv();
 
-    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+localClass = curEnv->FindClass( this->className().c_str() ) ;
+if (localClass == NULL) {
+  throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+}
 
-    /* localClass is not needed anymore */
-    curEnv->DeleteLocalRef(localClass);
+this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
 
-    if (this->instanceClass == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+/* localClass is not needed anymore */
+curEnv->DeleteLocalRef(localClass);
 
+if (this->instanceClass == NULL) {
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
-    if (constructObject == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
 
-    localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
-    if (localInstance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
+if(constructObject == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    this->instance = curEnv->NewGlobalRef(localInstance) ;
-    if (this->instance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-    /* localInstance not needed anymore */
-    curEnv->DeleteLocalRef(localInstance);
+localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
+if(localInstance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+this->instance = curEnv->NewGlobalRef(localInstance) ;
+if(this->instance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+/* localInstance not needed anymore */
+curEnv->DeleteLocalRef(localInstance);
 
-    /* Methods ID set to NULL */
-    jintnewInstancejintintjintArray_intintID = NULL;
+                /* 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)
+int ScilabJavaClass::newInstance (JavaVM * jvm_, int id, int const* args, int argsSize){
+
+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);
+}
 
-    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;
+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 a2003c1..e0a39d1 100644 (file)
@@ -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,108 @@ typedef signed char byte;
 # 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_);
-
-    /**
-    * 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
-
-    // Destructor
-    ~ScilabJavaClass();
-
-    // 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";
-    }
+// 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);
 
-    /**
-    * Get class to use for static methods
-    * @return class to use for static methods
-    */
 
-    static jclass initClass(JNIEnv * curEnv)
-    {
-        static jclass cls = 0;
+/** 
+* This is a fake constructor to avoid the constructor
+* chaining when dealing with extended giws classes 
+*/
+#ifdef FAKEGIWSDATATYPE
+ScilabJavaClass(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
+#endif
 
-        if (cls == 0)
-        {
-            jclass _cls = curEnv->FindClass(className().c_str());
-            if (_cls)
-            {
-                cls = static_cast<jclass>(curEnv->NewGlobalRef(_cls));
-            }
-        }
+// Destructor
+~ScilabJavaClass();
 
-        return cls;
-    }
+// 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 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 6bc9a17..8b453d0 100644 (file)
@@ -36,189 +36,167 @@ The fact that you are presently reading this means that you have had
 knowledge of the CeCILL-B license and that you accept its terms.
 */
 
-namespace org_scilab_modules_external_objects_java
-{
-
-// Static declarations (if any)
+namespace org_scilab_modules_external_objects_java {
 
+                // Static declarations (if any)
+                
 // Returns the current env
 
-JNIEnv * ScilabJavaCompiler::getCurrentEnv()
-{
-    JNIEnv * curEnv = NULL;
-    jint res = this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    if (res != JNI_OK)
-    {
-        throw GiwsException::JniException(getCurrentEnv());
-    }
-    return curEnv;
+JNIEnv * ScilabJavaCompiler::getCurrentEnv() {
+JNIEnv * curEnv = NULL;
+jint res=this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+if (res != JNI_OK) {
+throw GiwsException::JniException(getCurrentEnv());
+}
+return curEnv;
 }
 // Destructor
 
-ScilabJavaCompiler::~ScilabJavaCompiler()
-{
-    JNIEnv * curEnv = NULL;
-    this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    curEnv->DeleteGlobalRef(this->instance);
-    curEnv->DeleteGlobalRef(this->instanceClass);
-    curEnv->DeleteGlobalRef(this->stringArrayClass);
-}
+ScilabJavaCompiler::~ScilabJavaCompiler() {
+JNIEnv * curEnv = NULL;
+this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+curEnv->DeleteGlobalRef(this->instance);
+curEnv->DeleteGlobalRef(this->instanceClass);
+curEnv->DeleteGlobalRef(this->stringArrayClass);}
 // Constructors
-ScilabJavaCompiler::ScilabJavaCompiler(JavaVM * jvm_)
-{
-    jmethodID constructObject = NULL ;
-    jobject localInstance ;
-    jclass localClass ;
+ScilabJavaCompiler::ScilabJavaCompiler(JavaVM * jvm_) {
+jmethodID constructObject = NULL ;
+jobject localInstance ;
+jclass localClass ;
 
-    const std::string construct = "<init>";
-    const std::string param = "()V";
-    jvm = jvm_;
+const std::string construct="<init>";
+const std::string param="()V";
+jvm=jvm_;
 
-    JNIEnv * curEnv = getCurrentEnv();
+JNIEnv * curEnv = getCurrentEnv();
 
-    localClass = curEnv->FindClass( this->className().c_str() ) ;
-    if (localClass == NULL)
-    {
-        throw GiwsException::JniClassNotFoundException(curEnv, this->className());
-    }
-
-    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+localClass = curEnv->FindClass( this->className().c_str() ) ;
+if (localClass == NULL) {
+  throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+}
 
-    /* localClass is not needed anymore */
-    curEnv->DeleteLocalRef(localClass);
+this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
 
-    if (this->instanceClass == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+/* localClass is not needed anymore */
+curEnv->DeleteLocalRef(localClass);
 
+if (this->instanceClass == NULL) {
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
-    if (constructObject == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
 
-    localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
-    if (localInstance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
+if(constructObject == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    this->instance = curEnv->NewGlobalRef(localInstance) ;
-    if (this->instance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-    /* localInstance not needed anymore */
-    curEnv->DeleteLocalRef(localInstance);
+localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
+if(localInstance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+this->instance = curEnv->NewGlobalRef(localInstance) ;
+if(this->instance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+/* localInstance not needed anymore */
+curEnv->DeleteLocalRef(localInstance);
 
-    /* Methods ID set to NULL */
-    jintcompileCodejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID = NULL;
+                /* Methods ID set to NULL */
+jintcompileCodejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
 
 
 }
 
-ScilabJavaCompiler::ScilabJavaCompiler(JavaVM * jvm_, jobject JObj)
-{
-    jvm = jvm_;
+ScilabJavaCompiler::ScilabJavaCompiler(JavaVM * jvm_, jobject JObj) {
+        jvm=jvm_;
 
-    JNIEnv * curEnv = getCurrentEnv();
+        JNIEnv * curEnv = getCurrentEnv();
 
-    jclass localClass = curEnv->GetObjectClass(JObj);
-    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
-    curEnv->DeleteLocalRef(localClass);
+jclass localClass = curEnv->GetObjectClass(JObj);
+        this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+        curEnv->DeleteLocalRef(localClass);
 
-    if (this->instanceClass == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+        if (this->instanceClass == NULL) {
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+        }
 
-    this->instance = curEnv->NewGlobalRef(JObj) ;
-    if (this->instance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-    /* Methods ID set to NULL */
-    jintcompileCodejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID = NULL;
+        this->instance = curEnv->NewGlobalRef(JObj) ;
+        if(this->instance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+        }
+        /* Methods ID set to NULL */
+        jintcompileCodejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
 
 
 }
 
 // Generic methods
 
-void ScilabJavaCompiler::synchronize()
+void ScilabJavaCompiler::synchronize() {
+if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
+throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaCompiler");
+}
+}
+
+void ScilabJavaCompiler::endSynchronize() {
+if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
+throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaCompiler");
+}
+}
+// Method(s)
+
+int ScilabJavaCompiler::compileCode (JavaVM * jvm_, char const* classname, char const* const* code, int codeSize){
+
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = 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)
 {
-    if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK)
-    {
-        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaCompiler");
-    }
+throw GiwsException::JniBadAllocException(curEnv);
 }
 
-void ScilabJavaCompiler::endSynchronize()
+jclass stringArrayClass = curEnv->FindClass("java/lang/String");
+
+// create java array of strings.
+jobjectArray code_ = curEnv->NewObjectArray( codeSize, stringArrayClass, NULL);
+if (code_ == NULL)
 {
-    if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK)
-    {
-        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaCompiler");
-    }
+throw GiwsException::JniBadAllocException(curEnv);
 }
-// Method(s)
 
-int ScilabJavaCompiler::compileCode (JavaVM * jvm_, char const* classname, char const* const* code, int codeSize)
+// convert each char * to java strings and fill the java array.
+for ( int i = 0; i < codeSize; i++)
+{
+jstring TempString = curEnv->NewStringUTF( code[i] );
+if (TempString == NULL)
 {
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = 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);
-        }
+curEnv->SetObjectArrayElement( code_, i, TempString);
 
-        curEnv->SetObjectArrayElement( code_, i, TempString);
-
-        // avoid keeping reference on too many strings
-        curEnv->DeleteLocalRef(TempString);
-    }
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcompileCodejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID , classname_, code_));
-    curEnv->DeleteLocalRef(stringArrayClass);
-    curEnv->DeleteLocalRef(classname_);
-    curEnv->DeleteLocalRef(code_);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+// avoid keeping reference on too many strings
+curEnv->DeleteLocalRef(TempString);
+}
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintcompileCodejstringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_StringID ,classname_, code_));
+                        curEnv->DeleteLocalRef(stringArrayClass);
+curEnv->DeleteLocalRef(classname_);
+curEnv->DeleteLocalRef(code_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
 }
 
index 8c972a2..732883d 100644 (file)
@@ -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,111 +69,109 @@ typedef signed char byte;
 # 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_);
-
-    /**
-    * 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
-
-    // Destructor
-    ~ScilabJavaCompiler();
-
-    // 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";
-    }
+// 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);
 
-    /**
-    * Get class to use for static methods
-    * @return class to use for static methods
-    */
 
-    static jclass initClass(JNIEnv * curEnv)
-    {
-        static jclass cls = 0;
+/** 
+* This is a fake constructor to avoid the constructor
+* chaining when dealing with extended giws classes 
+*/
+#ifdef FAKEGIWSDATATYPE
+ScilabJavaCompiler(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
+#endif
 
-        if (cls == 0)
-        {
-            jclass _cls = curEnv->FindClass(className().c_str());
-            if (_cls)
-            {
-                cls = static_cast<jclass>(curEnv->NewGlobalRef(_cls));
-            }
-        }
+// Destructor
+~ScilabJavaCompiler();
 
-        return cls;
-    }
+// 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 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 b26a45b..6ef4ca5 100644 (file)
@@ -36,2233 +36,1960 @@ The fact that you are presently reading this means that you have had
 knowledge of the CeCILL-B license and that you accept its terms.
 */
 
-namespace org_scilab_modules_external_objects_java
-{
-
-// Static declarations (if any)
+namespace org_scilab_modules_external_objects_java {
 
+                // Static declarations (if any)
+                
 // Returns the current env
 
-JNIEnv * ScilabJavaObject::getCurrentEnv()
-{
-    JNIEnv * curEnv = NULL;
-    jint res = this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    if (res != JNI_OK)
-    {
-        throw GiwsException::JniException(getCurrentEnv());
-    }
-    return curEnv;
+JNIEnv * ScilabJavaObject::getCurrentEnv() {
+JNIEnv * curEnv = NULL;
+jint res=this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+if (res != JNI_OK) {
+throw GiwsException::JniException(getCurrentEnv());
+}
+return curEnv;
 }
 // Destructor
 
-ScilabJavaObject::~ScilabJavaObject()
-{
-    JNIEnv * curEnv = NULL;
-    this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    curEnv->DeleteGlobalRef(this->instance);
-    curEnv->DeleteGlobalRef(this->instanceClass);
-    curEnv->DeleteGlobalRef(this->stringArrayClass);
-}
+ScilabJavaObject::~ScilabJavaObject() {
+JNIEnv * curEnv = NULL;
+this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+curEnv->DeleteGlobalRef(this->instance);
+curEnv->DeleteGlobalRef(this->instanceClass);
+curEnv->DeleteGlobalRef(this->stringArrayClass);}
 // Constructors
-ScilabJavaObject::ScilabJavaObject(JavaVM * jvm_)
-{
-    jmethodID constructObject = NULL ;
-    jobject localInstance ;
-    jclass localClass ;
-
-    const std::string construct = "<init>";
-    const std::string param = "()V";
-    jvm = jvm_;
-
-    JNIEnv * curEnv = getCurrentEnv();
-
-    localClass = curEnv->FindClass( this->className().c_str() ) ;
-    if (localClass == NULL)
-    {
-        throw GiwsException::JniClassNotFoundException(curEnv, this->className());
-    }
-
-    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
-
-    /* localClass is not needed anymore */
-    curEnv->DeleteLocalRef(localClass);
-
-    if (this->instanceClass == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-
-
-    constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
-    if (constructObject == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-
-    localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
-    if (localInstance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-
-    this->instance = curEnv->NewGlobalRef(localInstance) ;
-    if (this->instance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-    /* localInstance not needed anymore */
-    curEnv->DeleteLocalRef(localInstance);
-
-    /* Methods ID set to NULL */
-    jintinvokejintintjstringjava_lang_StringjintArray_intintID = NULL;
-    jintextractjintintjintArray_intintID = NULL;
-    voidinsertjintintjintArray_intintjintintID = NULL;
-    jobjectArray_getInfosID = NULL;
-    voidinitScilabJavaObjectID = NULL;
-    voidgarbageCollectID = NULL;
-    jstringgetRepresentationjintintID = NULL;
-    jbooleanisValidJavaObjectjintintID = NULL;
-    voidenableTracejstringjava_lang_StringID = NULL;
-    voiddisableTraceID = NULL;
-    voidwriteLogjstringjava_lang_StringID = NULL;
-    voidsetFieldjintintjstringjava_lang_StringjintintID = NULL;
-    jintgetFieldjintintjstringjava_lang_StringID = NULL;
-    jintgetFieldTypejintintjstringjava_lang_StringID = NULL;
-    jintjavaCastjintintjstringjava_lang_StringID = NULL;
-    jintjavaCastjintintjintintID = NULL;
-    jstringgetClassNamejintintID = NULL;
-    jintgetArrayElementjintintjintArray_intintID = NULL;
-    voidsetArrayElementjintintjintArray_intintjintintID = NULL;
-    voidremoveScilabJavaObjectjintintID = NULL;
-    voidremoveScilabJavaObjectjintArray_intintID = NULL;
-    voidlimitDirectBufferjintintID = NULL;
-    jintisUnwrappablejintintID = NULL;
-    jintwrapjdoubledoubleID = NULL;
-    jintwrapjdoubleArray_doubledoubleID = NULL;
-    jintwrapjobjectArray__doubledoubleID = NULL;
-    jintwrapjintintID = NULL;
-    jintwrapjintArray_intintID = NULL;
-    jintwrapjobjectArray__intintID = NULL;
-    jintwrapjbytebyteID = NULL;
-    jintwrapjbyteArray_bytebyteID = NULL;
-    jintwrapjobjectArray__bytebyteID = NULL;
-    jintwrapjshortshortID = NULL;
-    jintwrapjshortArray_shortshortID = NULL;
-    jintwrapjobjectArray__shortshortID = NULL;
-    jintwrapjstringjava_lang_StringID = NULL;
-    jintwrapjobjectArray_java_lang_Stringjava_lang_StringID = NULL;
-    jintwrapjobjectArray__java_lang_Stringjava_lang_StringID = NULL;
-    jintwrapjbooleanbooleanID = NULL;
-    jintwrapjbooleanArray_booleanbooleanID = NULL;
-    jintwrapjobjectArray__booleanbooleanID = NULL;
-    jintwrapjcharcharID = NULL;
-    jintwrapjcharArray_charcharID = NULL;
-    jintwrapjobjectArray__charcharID = NULL;
-    jintwrapjfloatfloatID = NULL;
-    jintwrapjfloatArray_floatfloatID = NULL;
-    jintwrapjobjectArray__floatfloatID = NULL;
-    jintwrapjlonglongID = NULL;
-    jintwrapjlongArray_longlongID = NULL;
-    jintwrapjobjectArray__longlongID = NULL;
-    jobjectArray_getAccessibleFieldsjintintID = NULL;
-    jobjectArray_getAccessibleMethodsjintintID = NULL;
-    jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID = NULL;
-
-
-}
-
-ScilabJavaObject::ScilabJavaObject(JavaVM * jvm_, jobject JObj)
-{
-    jvm = jvm_;
-
-    JNIEnv * curEnv = getCurrentEnv();
-
-    jclass localClass = curEnv->GetObjectClass(JObj);
-    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
-    curEnv->DeleteLocalRef(localClass);
-
-    if (this->instanceClass == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-
-    this->instance = curEnv->NewGlobalRef(JObj) ;
-    if (this->instance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-    /* Methods ID set to NULL */
-    jintinvokejintintjstringjava_lang_StringjintArray_intintID = NULL;
-    jintextractjintintjintArray_intintID = NULL;
-    voidinsertjintintjintArray_intintjintintID = NULL;
-    jobjectArray_getInfosID = NULL;
-    voidinitScilabJavaObjectID = NULL;
-    voidgarbageCollectID = NULL;
-    jstringgetRepresentationjintintID = NULL;
-    jbooleanisValidJavaObjectjintintID = NULL;
-    voidenableTracejstringjava_lang_StringID = NULL;
-    voiddisableTraceID = NULL;
-    voidwriteLogjstringjava_lang_StringID = NULL;
-    voidsetFieldjintintjstringjava_lang_StringjintintID = NULL;
-    jintgetFieldjintintjstringjava_lang_StringID = NULL;
-    jintgetFieldTypejintintjstringjava_lang_StringID = NULL;
-    jintjavaCastjintintjstringjava_lang_StringID = NULL;
-    jintjavaCastjintintjintintID = NULL;
-    jstringgetClassNamejintintID = NULL;
-    jintgetArrayElementjintintjintArray_intintID = NULL;
-    voidsetArrayElementjintintjintArray_intintjintintID = NULL;
-    voidremoveScilabJavaObjectjintintID = NULL;
-    voidremoveScilabJavaObjectjintArray_intintID = NULL;
-    voidlimitDirectBufferjintintID = NULL;
-    jintisUnwrappablejintintID = NULL;
-    jintwrapjdoubledoubleID = NULL;
-    jintwrapjdoubleArray_doubledoubleID = NULL;
-    jintwrapjobjectArray__doubledoubleID = NULL;
-    jintwrapjintintID = NULL;
-    jintwrapjintArray_intintID = NULL;
-    jintwrapjobjectArray__intintID = NULL;
-    jintwrapjbytebyteID = NULL;
-    jintwrapjbyteArray_bytebyteID = NULL;
-    jintwrapjobjectArray__bytebyteID = NULL;
-    jintwrapjshortshortID = NULL;
-    jintwrapjshortArray_shortshortID = NULL;
-    jintwrapjobjectArray__shortshortID = NULL;
-    jintwrapjstringjava_lang_StringID = NULL;
-    jintwrapjobjectArray_java_lang_Stringjava_lang_StringID = NULL;
-    jintwrapjobjectArray__java_lang_Stringjava_lang_StringID = NULL;
-    jintwrapjbooleanbooleanID = NULL;
-    jintwrapjbooleanArray_booleanbooleanID = NULL;
-    jintwrapjobjectArray__booleanbooleanID = NULL;
-    jintwrapjcharcharID = NULL;
-    jintwrapjcharArray_charcharID = NULL;
-    jintwrapjobjectArray__charcharID = NULL;
-    jintwrapjfloatfloatID = NULL;
-    jintwrapjfloatArray_floatfloatID = NULL;
-    jintwrapjobjectArray__floatfloatID = NULL;
-    jintwrapjlonglongID = NULL;
-    jintwrapjlongArray_longlongID = NULL;
-    jintwrapjobjectArray__longlongID = NULL;
-    jobjectArray_getAccessibleFieldsjintintID = NULL;
-    jobjectArray_getAccessibleMethodsjintintID = NULL;
-    jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID = NULL;
+ScilabJavaObject::ScilabJavaObject(JavaVM * jvm_) {
+jmethodID constructObject = NULL ;
+jobject localInstance ;
+jclass localClass ;
+
+const std::string construct="<init>";
+const std::string param="()V";
+jvm=jvm_;
+
+JNIEnv * curEnv = getCurrentEnv();
+
+localClass = curEnv->FindClass( this->className().c_str() ) ;
+if (localClass == NULL) {
+  throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+}
+
+this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+
+/* localClass is not needed anymore */
+curEnv->DeleteLocalRef(localClass);
+
+if (this->instanceClass == NULL) {
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+
+
+constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
+if(constructObject == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+
+localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
+if(localInstance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+this->instance = curEnv->NewGlobalRef(localInstance) ;
+if(this->instance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+/* localInstance not needed anymore */
+curEnv->DeleteLocalRef(localInstance);
+
+                /* Methods ID set to NULL */
+jintinvokejintintjstringjava_lang_StringjintArray_intintID=NULL;
+jintextractjintintjintArray_intintID=NULL;
+voidinsertjintintjintArray_intintjintintID=NULL;
+jobjectArray_getInfosID=NULL;
+voidinitScilabJavaObjectID=NULL;
+voidgarbageCollectID=NULL;
+jstringgetRepresentationjintintID=NULL;
+jbooleanisValidJavaObjectjintintID=NULL;
+voidenableTracejstringjava_lang_StringID=NULL;
+voiddisableTraceID=NULL;
+voidwriteLogjstringjava_lang_StringID=NULL;
+voidsetFieldjintintjstringjava_lang_StringjintintID=NULL;
+jintgetFieldjintintjstringjava_lang_StringID=NULL;
+jintgetFieldTypejintintjstringjava_lang_StringID=NULL;
+jintjavaCastjintintjstringjava_lang_StringID=NULL;
+jintjavaCastjintintjintintID=NULL;
+jstringgetClassNamejintintID=NULL;
+jintgetArrayElementjintintjintArray_intintID=NULL;
+voidsetArrayElementjintintjintArray_intintjintintID=NULL;
+voidremoveScilabJavaObjectjintintID=NULL;
+voidremoveScilabJavaObjectjintArray_intintID=NULL;
+voidlimitDirectBufferjintintID=NULL;
+jintisUnwrappablejintintID=NULL;
+jintwrapjdoubledoubleID=NULL;
+jintwrapjdoubleArray_doubledoubleID=NULL;
+jintwrapjobjectArray__doubledoubleID=NULL;
+jintwrapjintintID=NULL;
+jintwrapjintArray_intintID=NULL;
+jintwrapjobjectArray__intintID=NULL;
+jintwrapjbytebyteID=NULL;
+jintwrapjbyteArray_bytebyteID=NULL;
+jintwrapjobjectArray__bytebyteID=NULL;
+jintwrapjshortshortID=NULL;
+jintwrapjshortArray_shortshortID=NULL;
+jintwrapjobjectArray__shortshortID=NULL;
+jintwrapjstringjava_lang_StringID=NULL;
+jintwrapjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
+jintwrapjobjectArray__java_lang_Stringjava_lang_StringID=NULL;
+jintwrapjbooleanbooleanID=NULL;
+jintwrapjbooleanArray_booleanbooleanID=NULL;
+jintwrapjobjectArray__booleanbooleanID=NULL;
+jintwrapjcharcharID=NULL;
+jintwrapjcharArray_charcharID=NULL;
+jintwrapjobjectArray__charcharID=NULL;
+jintwrapjfloatfloatID=NULL;
+jintwrapjfloatArray_floatfloatID=NULL;
+jintwrapjobjectArray__floatfloatID=NULL;
+jintwrapjlonglongID=NULL;
+jintwrapjlongArray_longlongID=NULL;
+jintwrapjobjectArray__longlongID=NULL;
+jobjectArray_getAccessibleFieldsjintintID=NULL;
+jobjectArray_getAccessibleMethodsjintintID=NULL;
+jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
+
+
+}
+
+ScilabJavaObject::ScilabJavaObject(JavaVM * jvm_, jobject JObj) {
+        jvm=jvm_;
+
+        JNIEnv * curEnv = getCurrentEnv();
+
+jclass localClass = curEnv->GetObjectClass(JObj);
+        this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+        curEnv->DeleteLocalRef(localClass);
+
+        if (this->instanceClass == NULL) {
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+        }
+
+        this->instance = curEnv->NewGlobalRef(JObj) ;
+        if(this->instance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+        }
+        /* Methods ID set to NULL */
+        jintinvokejintintjstringjava_lang_StringjintArray_intintID=NULL;
+jintextractjintintjintArray_intintID=NULL;
+voidinsertjintintjintArray_intintjintintID=NULL;
+jobjectArray_getInfosID=NULL;
+voidinitScilabJavaObjectID=NULL;
+voidgarbageCollectID=NULL;
+jstringgetRepresentationjintintID=NULL;
+jbooleanisValidJavaObjectjintintID=NULL;
+voidenableTracejstringjava_lang_StringID=NULL;
+voiddisableTraceID=NULL;
+voidwriteLogjstringjava_lang_StringID=NULL;
+voidsetFieldjintintjstringjava_lang_StringjintintID=NULL;
+jintgetFieldjintintjstringjava_lang_StringID=NULL;
+jintgetFieldTypejintintjstringjava_lang_StringID=NULL;
+jintjavaCastjintintjstringjava_lang_StringID=NULL;
+jintjavaCastjintintjintintID=NULL;
+jstringgetClassNamejintintID=NULL;
+jintgetArrayElementjintintjintArray_intintID=NULL;
+voidsetArrayElementjintintjintArray_intintjintintID=NULL;
+voidremoveScilabJavaObjectjintintID=NULL;
+voidremoveScilabJavaObjectjintArray_intintID=NULL;
+voidlimitDirectBufferjintintID=NULL;
+jintisUnwrappablejintintID=NULL;
+jintwrapjdoubledoubleID=NULL;
+jintwrapjdoubleArray_doubledoubleID=NULL;
+jintwrapjobjectArray__doubledoubleID=NULL;
+jintwrapjintintID=NULL;
+jintwrapjintArray_intintID=NULL;
+jintwrapjobjectArray__intintID=NULL;
+jintwrapjbytebyteID=NULL;
+jintwrapjbyteArray_bytebyteID=NULL;
+jintwrapjobjectArray__bytebyteID=NULL;
+jintwrapjshortshortID=NULL;
+jintwrapjshortArray_shortshortID=NULL;
+jintwrapjobjectArray__shortshortID=NULL;
+jintwrapjstringjava_lang_StringID=NULL;
+jintwrapjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
+jintwrapjobjectArray__java_lang_Stringjava_lang_StringID=NULL;
+jintwrapjbooleanbooleanID=NULL;
+jintwrapjbooleanArray_booleanbooleanID=NULL;
+jintwrapjobjectArray__booleanbooleanID=NULL;
+jintwrapjcharcharID=NULL;
+jintwrapjcharArray_charcharID=NULL;
+jintwrapjobjectArray__charcharID=NULL;
+jintwrapjfloatfloatID=NULL;
+jintwrapjfloatArray_floatfloatID=NULL;
+jintwrapjobjectArray__floatfloatID=NULL;
+jintwrapjlonglongID=NULL;
+jintwrapjlongArray_longlongID=NULL;
+jintwrapjobjectArray__longlongID=NULL;
+jobjectArray_getAccessibleFieldsjintintID=NULL;
+jobjectArray_getAccessibleMethodsjintintID=NULL;
+jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
 
 
 }
 
 // Generic methods
 
-void ScilabJavaObject::synchronize()
-{
-    if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK)
-    {
-        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaObject");
-    }
+void ScilabJavaObject::synchronize() {
+if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
+throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaObject");
+}
 }
 
-void ScilabJavaObject::endSynchronize()
-{
-    if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK)
-    {
-        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaObject");
-    }
+void ScilabJavaObject::endSynchronize() {
+if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
+throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaObject");
+}
 }
 // Method(s)
 
-int ScilabJavaObject::invoke (JavaVM * jvm_, int id, char const* methodName, int const* args, int argsSize)
+int ScilabJavaObject::invoke (JavaVM * jvm_, int id, char const* methodName, int const* args, int argsSize){
+
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+
+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");
+}
+
+jstring methodName_ = curEnv->NewStringUTF( methodName );
+if (methodName != NULL && methodName_ == NULL)
 {
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
 
-    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");
-    }
+jintArray args_ = curEnv->NewIntArray( argsSize ) ;
 
-    jstring methodName_ = curEnv->NewStringUTF( methodName );
-    if (methodName != NULL && methodName_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+if (args_ == NULL)
+{
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
+curEnv->SetIntArrayRegion( args_, 0, argsSize, (jint*)(args) ) ;
 
-    jintArray args_ = curEnv->NewIntArray( argsSize ) ;
 
-    if (args_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintinvokejintintjstringjava_lang_StringjintArray_intintID ,id, methodName_, args_));
+                        curEnv->DeleteLocalRef(methodName_);
+curEnv->DeleteLocalRef(args_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    curEnv->SetIntArrayRegion( args_, 0, argsSize, (jint*)(args) ) ;
+}
 
+int ScilabJavaObject::extract (JavaVM * jvm_, int id, int const* args, int argsSize){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintinvokejintintjstringjava_lang_StringjintArray_intintID , id, methodName_, args_));
-    curEnv->DeleteLocalRef(methodName_);
-    curEnv->DeleteLocalRef(args_);
-    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 jintextractjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "extract", "(I[I)I" ) ;
+if (jintextractjintintjintArray_intintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "extract");
 }
 
-int ScilabJavaObject::extract (JavaVM * jvm_, int id, int const* args, int argsSize)
-{
+jintArray args_ = curEnv->NewIntArray( argsSize ) ;
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+if (args_ == NULL)
+{
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    static jmethodID jintextractjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "extract", "(I[I)I" ) ;
-    if (jintextractjintintjintArray_intintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "extract");
-    }
+curEnv->SetIntArrayRegion( args_, 0, argsSize, (jint*)(args) ) ;
 
-    jintArray args_ = curEnv->NewIntArray( argsSize ) ;
 
-    if (args_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintextractjintintjintArray_intintID ,id, args_));
+                        curEnv->DeleteLocalRef(args_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    curEnv->SetIntArrayRegion( args_, 0, argsSize, (jint*)(args) ) ;
+}
 
+void ScilabJavaObject::insert (JavaVM * jvm_, int id, int const* keys, int keysSize, int value){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintextractjintintjintArray_intintID , id, args_));
-    curEnv->DeleteLocalRef(args_);
-    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 voidinsertjintintjintArray_intintjintintID = curEnv->GetStaticMethodID(cls, "insert", "(I[II)V" ) ;
+if (voidinsertjintintjintArray_intintjintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "insert");
 }
 
-void ScilabJavaObject::insert (JavaVM * jvm_, int id, int const* keys, int keysSize, int value)
+jintArray keys_ = curEnv->NewIntArray( keysSize ) ;
+
+if (keys_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+curEnv->SetIntArrayRegion( keys_, 0, keysSize, (jint*)(keys) ) ;
 
-    static jmethodID voidinsertjintintjintArray_intintjintintID = curEnv->GetStaticMethodID(cls, "insert", "(I[II)V" ) ;
-    if (voidinsertjintintjintArray_intintjintintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "insert");
-    }
 
-    jintArray keys_ = curEnv->NewIntArray( keysSize ) ;
+                         curEnv->CallStaticVoidMethod(cls, voidinsertjintintjintArray_intintjintintID ,id, keys_, value);
+                        curEnv->DeleteLocalRef(keys_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+}
 
-    if (keys_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+char** ScilabJavaObject::getInfos (JavaVM * jvm_, int *lenRow){
 
-    curEnv->SetIntArrayRegion( keys_, 0, keysSize, (jint*)(keys) ) ;
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = 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");
+}
 
-    curEnv->CallStaticVoidMethod(cls, voidinsertjintintjintArray_intintjintintID , id, keys_, value);
-    curEnv->DeleteLocalRef(keys_);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+                        jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray_getInfosID ));
+                        if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}if (res != NULL) { 
+* lenRow = curEnv->GetArrayLength(res);
+
+char **arrayOfString;
+arrayOfString = new char *[*lenRow];
+for (jsize i = 0; i < *lenRow; i++){
+jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
+const char *tempString = curEnv->GetStringUTFChars(resString, 0);
+arrayOfString[i] = new char[strlen(tempString) + 1];
+
+strcpy(arrayOfString[i], tempString);
+curEnv->ReleaseStringUTFChars(resString, tempString);
+curEnv->DeleteLocalRef(resString);
+}
+if (curEnv->ExceptionCheck()) {
+delete[] arrayOfString;
+                                throw GiwsException::JniCallMethodException(curEnv);
+}
+curEnv->DeleteLocalRef(res);
+return arrayOfString;
+ } else { 
+curEnv->DeleteLocalRef(res);
+return NULL;
+}
 }
 
-char** ScilabJavaObject::getInfos (JavaVM * jvm_, int *lenRow)
-{
+void ScilabJavaObject::initScilabJavaObject (JavaVM * jvm_){
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = 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;
-    }
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-void ScilabJavaObject::initScilabJavaObject (JavaVM * jvm_)
-{
+static jmethodID voidinitScilabJavaObjectID = curEnv->GetStaticMethodID(cls, "initScilabJavaObject", "()V" ) ;
+if (voidinitScilabJavaObjectID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "initScilabJavaObject");
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+                         curEnv->CallStaticVoidMethod(cls, voidinitScilabJavaObjectID );
+                        if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+}
 
-    static jmethodID voidinitScilabJavaObjectID = curEnv->GetStaticMethodID(cls, "initScilabJavaObject", "()V" ) ;
-    if (voidinitScilabJavaObjectID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "initScilabJavaObject");
-    }
+void ScilabJavaObject::garbageCollect (JavaVM * jvm_){
 
-    curEnv->CallStaticVoidMethod(cls, voidinitScilabJavaObjectID );
-    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);
 }
 
-void ScilabJavaObject::garbageCollect (JavaVM * jvm_)
-{
+static jmethodID voidgarbageCollectID = curEnv->GetStaticMethodID(cls, "garbageCollect", "()V" ) ;
+if (voidgarbageCollectID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "garbageCollect");
+}
+
+                         curEnv->CallStaticVoidMethod(cls, voidgarbageCollectID );
+                        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::getRepresentation (JavaVM * jvm_, int id){
 
-    static jmethodID voidgarbageCollectID = curEnv->GetStaticMethodID(cls, "garbageCollect", "()V" ) ;
-    if (voidgarbageCollectID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "garbageCollect");
-    }
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
-    curEnv->CallStaticVoidMethod(cls, voidgarbageCollectID );
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+static jmethodID jstringgetRepresentationjintintID = curEnv->GetStaticMethodID(cls, "getRepresentation", "(I)Ljava/lang/String;" ) ;
+if (jstringgetRepresentationjintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "getRepresentation");
 }
 
-char* ScilabJavaObject::getRepresentation (JavaVM * jvm_, int id)
-{
+                        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;
+}
+}
 
-    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;
-    }
+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);
 }
 
-bool ScilabJavaObject::isValidJavaObject (JavaVM * jvm_, int id)
-{
+static jmethodID jbooleanisValidJavaObjectjintintID = curEnv->GetStaticMethodID(cls, "isValidJavaObject", "(I)Z" ) ;
+if (jbooleanisValidJavaObjectjintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "isValidJavaObject");
+}
+
+                        jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanisValidJavaObjectjintintID ,id));
+                        if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return (res == JNI_TRUE);
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+}
 
-    static jmethodID jbooleanisValidJavaObjectjintintID = curEnv->GetStaticMethodID(cls, "isValidJavaObject", "(I)Z" ) ;
-    if (jbooleanisValidJavaObjectjintintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "isValidJavaObject");
-    }
+void ScilabJavaObject::enableTrace (JavaVM * jvm_, char const* filename){
 
-    jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanisValidJavaObjectjintintID , id));
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return (res == JNI_TRUE);
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+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::enableTrace (JavaVM * jvm_, char const* filename)
+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 = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        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");
-    }
+                         curEnv->CallStaticVoidMethod(cls, voidenableTracejstringjava_lang_StringID ,filename_);
+                        curEnv->DeleteLocalRef(filename_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+}
 
-    jstring filename_ = curEnv->NewStringUTF( filename );
-    if (filename != NULL && filename_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+void ScilabJavaObject::disableTrace (JavaVM * jvm_){
 
+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_);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+static jmethodID voiddisableTraceID = curEnv->GetStaticMethodID(cls, "disableTrace", "()V" ) ;
+if (voiddisableTraceID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "disableTrace");
 }
 
-void ScilabJavaObject::disableTrace (JavaVM * jvm_)
-{
+                         curEnv->CallStaticVoidMethod(cls, voiddisableTraceID );
+                        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);
-    }
+void ScilabJavaObject::writeLog (JavaVM * jvm_, char const* s){
 
-    static jmethodID voiddisableTraceID = curEnv->GetStaticMethodID(cls, "disableTrace", "()V" ) ;
-    if (voiddisableTraceID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "disableTrace");
-    }
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
-    curEnv->CallStaticVoidMethod(cls, voiddisableTraceID );
-    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::writeLog (JavaVM * jvm_, char const* s)
+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 = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        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");
-    }
+                         curEnv->CallStaticVoidMethod(cls, voidwriteLogjstringjava_lang_StringID ,s_);
+                        curEnv->DeleteLocalRef(s_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+}
 
-    jstring s_ = curEnv->NewStringUTF( s );
-    if (s != NULL && s_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+void ScilabJavaObject::setField (JavaVM * jvm_, int id, char const* fieldName, int idarg){
 
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
-    curEnv->CallStaticVoidMethod(cls, voidwriteLogjstringjava_lang_StringID , s_);
-    curEnv->DeleteLocalRef(s_);
-    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");
 }
 
-void ScilabJavaObject::setField (JavaVM * jvm_, int id, char const* fieldName, int idarg)
+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 = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        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");
-    }
+                         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)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+int ScilabJavaObject::getField (JavaVM * jvm_, int id, char const* fieldName){
 
+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_);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+static jmethodID jintgetFieldjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "getField", "(ILjava/lang/String;)I" ) ;
+if (jintgetFieldjintintjstringjava_lang_StringID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "getField");
 }
 
-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 = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
 
-    static jmethodID jintgetFieldjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "getField", "(ILjava/lang/String;)I" ) ;
-    if (jintgetFieldjintintjstringjava_lang_StringID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "getField");
-    }
+                        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;
 
-    jstring fieldName_ = curEnv->NewStringUTF( fieldName );
-    if (fieldName != NULL && fieldName_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+}
 
+int ScilabJavaObject::getFieldType (JavaVM * jvm_, int id, char const* fieldName){
 
-    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;
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+static jmethodID jintgetFieldTypejintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "getFieldType", "(ILjava/lang/String;)I" ) ;
+if (jintgetFieldTypejintintjstringjava_lang_StringID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "getFieldType");
 }
 
-int ScilabJavaObject::getFieldType (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 = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
 
-    static jmethodID jintgetFieldTypejintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "getFieldType", "(ILjava/lang/String;)I" ) ;
-    if (jintgetFieldTypejintintjstringjava_lang_StringID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "getFieldType");
-    }
+                        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;
 
-    jstring fieldName_ = curEnv->NewStringUTF( fieldName );
-    if (fieldName != NULL && fieldName_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+}
 
+int ScilabJavaObject::javaCast (JavaVM * jvm_, int id, char const* objName){
 
-    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;
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+static jmethodID jintjavaCastjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "javaCast", "(ILjava/lang/String;)I" ) ;
+if (jintjavaCastjintintjstringjava_lang_StringID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "javaCast");
 }
 
-int ScilabJavaObject::javaCast (JavaVM * jvm_, int id, char const* objName)
+jstring objName_ = curEnv->NewStringUTF( objName );
+if (objName != NULL && objName_ == NULL)
 {
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
 
-    static jmethodID jintjavaCastjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "javaCast", "(ILjava/lang/String;)I" ) ;
-    if (jintjavaCastjintintjstringjava_lang_StringID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "javaCast");
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintjavaCastjintintjstringjava_lang_StringID ,id, objName_));
+                        curEnv->DeleteLocalRef(objName_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    jstring objName_ = curEnv->NewStringUTF( objName );
-    if (objName != NULL && objName_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+}
 
+int ScilabJavaObject::javaCast (JavaVM * jvm_, int id, int classId){
 
-    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;
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+static jmethodID jintjavaCastjintintjintintID = curEnv->GetStaticMethodID(cls, "javaCast", "(II)I" ) ;
+if (jintjavaCastjintintjintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "javaCast");
 }
 
-int ScilabJavaObject::javaCast (JavaVM * jvm_, int id, int classId)
-{
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintjavaCastjintintjintintID ,id, classId));
+                        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 jintjavaCastjintintjintintID = curEnv->GetStaticMethodID(cls, "javaCast", "(II)I" ) ;
-    if (jintjavaCastjintintjintintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "javaCast");
-    }
+char* ScilabJavaObject::getClassName (JavaVM * jvm_, int id){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintjavaCastjintintjintintID , id, classId));
-    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 jstringgetClassNamejintintID = curEnv->GetStaticMethodID(cls, "getClassName", "(I)Ljava/lang/String;" ) ;
+if (jstringgetClassNamejintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "getClassName");
 }
 
-char* ScilabJavaObject::getClassName (JavaVM * jvm_, int id)
-{
+                        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;
+}
+}
 
-    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;
-    }
+int ScilabJavaObject::getArrayElement (JavaVM * jvm_, int id, int const* index, int indexSize){
+
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-int ScilabJavaObject::getArrayElement (JavaVM * jvm_, int id, int const* index, int indexSize)
-{
+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 ) ;
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+if (index_ == NULL)
+{
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    static jmethodID jintgetArrayElementjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "getArrayElement", "(I[I)I" ) ;
-    if (jintgetArrayElementjintintjintArray_intintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "getArrayElement");
-    }
+curEnv->SetIntArrayRegion( index_, 0, indexSize, (jint*)(index) ) ;
 
-    jintArray index_ = curEnv->NewIntArray( indexSize ) ;
 
-    if (index_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetArrayElementjintintjintArray_intintID ,id, index_));
+                        curEnv->DeleteLocalRef(index_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    curEnv->SetIntArrayRegion( index_, 0, indexSize, (jint*)(index) ) ;
+}
 
+void ScilabJavaObject::setArrayElement (JavaVM * jvm_, int id, int const* index, int indexSize, int idArg){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetArrayElementjintintjintArray_intintID , id, index_));
-    curEnv->DeleteLocalRef(index_);
-    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 voidsetArrayElementjintintjintArray_intintjintintID = curEnv->GetStaticMethodID(cls, "setArrayElement", "(I[II)V" ) ;
+if (voidsetArrayElementjintintjintArray_intintjintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "setArrayElement");
 }
 
-void ScilabJavaObject::setArrayElement (JavaVM * jvm_, int id, int const* index, int indexSize, int idArg)
+jintArray index_ = curEnv->NewIntArray( indexSize ) ;
+
+if (index_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
+
+curEnv->SetIntArrayRegion( index_, 0, indexSize, (jint*)(index) ) ;
+
+
+                         curEnv->CallStaticVoidMethod(cls, voidsetArrayElementjintintjintArray_intintjintintID ,id, index_, idArg);
+                        curEnv->DeleteLocalRef(index_);
+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);
-    }
+void ScilabJavaObject::removeScilabJavaObject (JavaVM * jvm_, int id){
 
-    static jmethodID voidsetArrayElementjintintjintArray_intintjintintID = curEnv->GetStaticMethodID(cls, "setArrayElement", "(I[II)V" ) ;
-    if (voidsetArrayElementjintintjintArray_intintjintintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "setArrayElement");
-    }
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
-    jintArray index_ = curEnv->NewIntArray( indexSize ) ;
+static jmethodID voidremoveScilabJavaObjectjintintID = curEnv->GetStaticMethodID(cls, "removeScilabJavaObject", "(I)V" ) ;
+if (voidremoveScilabJavaObjectjintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "removeScilabJavaObject");
+}
 
-    if (index_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+                         curEnv->CallStaticVoidMethod(cls, voidremoveScilabJavaObjectjintintID ,id);
+                        if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+}
 
-    curEnv->SetIntArrayRegion( index_, 0, indexSize, (jint*)(index) ) ;
+void ScilabJavaObject::removeScilabJavaObject (JavaVM * jvm_, int const* id, int idSize){
 
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
-    curEnv->CallStaticVoidMethod(cls, voidsetArrayElementjintintjintArray_intintjintintID , id, index_, idArg);
-    curEnv->DeleteLocalRef(index_);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+static jmethodID voidremoveScilabJavaObjectjintArray_intintID = curEnv->GetStaticMethodID(cls, "removeScilabJavaObject", "([I)V" ) ;
+if (voidremoveScilabJavaObjectjintArray_intintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "removeScilabJavaObject");
 }
 
-void ScilabJavaObject::removeScilabJavaObject (JavaVM * jvm_, int id)
+jintArray id_ = curEnv->NewIntArray( idSize ) ;
+
+if (id_ == NULL)
 {
+// check that allocation succeed
+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->SetIntArrayRegion( id_, 0, idSize, (jint*)(id) ) ;
 
-    static jmethodID voidremoveScilabJavaObjectjintintID = curEnv->GetStaticMethodID(cls, "removeScilabJavaObject", "(I)V" ) ;
-    if (voidremoveScilabJavaObjectjintintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "removeScilabJavaObject");
-    }
 
-    curEnv->CallStaticVoidMethod(cls, voidremoveScilabJavaObjectjintintID , id);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+                         curEnv->CallStaticVoidMethod(cls, voidremoveScilabJavaObjectjintArray_intintID ,id_);
+                        curEnv->DeleteLocalRef(id_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 }
 
-void ScilabJavaObject::removeScilabJavaObject (JavaVM * jvm_, int const* id, int idSize)
-{
+void ScilabJavaObject::limitDirectBuffer (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 = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
-    static jmethodID voidremoveScilabJavaObjectjintArray_intintID = curEnv->GetStaticMethodID(cls, "removeScilabJavaObject", "([I)V" ) ;
-    if (voidremoveScilabJavaObjectjintArray_intintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "removeScilabJavaObject");
-    }
+static jmethodID voidlimitDirectBufferjintintID = curEnv->GetStaticMethodID(cls, "limitDirectBuffer", "(I)V" ) ;
+if (voidlimitDirectBufferjintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "limitDirectBuffer");
+}
 
-    jintArray id_ = curEnv->NewIntArray( idSize ) ;
+                         curEnv->CallStaticVoidMethod(cls, voidlimitDirectBufferjintintID ,id);
+                        if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+}
 
-    if (id_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+int ScilabJavaObject::isUnwrappable (JavaVM * jvm_, int id){
 
-    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 jintisUnwrappablejintintID = curEnv->GetStaticMethodID(cls, "isUnwrappable", "(I)I" ) ;
+if (jintisUnwrappablejintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "isUnwrappable");
+}
 
-    curEnv->CallStaticVoidMethod(cls, voidremoveScilabJavaObjectjintArray_intintID , id_);
-    curEnv->DeleteLocalRef(id_);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintisUnwrappablejintintID ,id));
+                        if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
+return res;
 
-void ScilabJavaObject::limitDirectBuffer (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 x){
 
-    static jmethodID voidlimitDirectBufferjintintID = curEnv->GetStaticMethodID(cls, "limitDirectBuffer", "(I)V" ) ;
-    if (voidlimitDirectBufferjintintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "limitDirectBuffer");
-    }
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
-    curEnv->CallStaticVoidMethod(cls, voidlimitDirectBufferjintintID , id);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+static jmethodID jintwrapjdoubledoubleID = curEnv->GetStaticMethodID(cls, "wrap", "(D)I" ) ;
+if (jintwrapjdoubledoubleID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-int ScilabJavaObject::isUnwrappable (JavaVM * jvm_, int id)
-{
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjdoubledoubleID ,x));
+                        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 jintisUnwrappablejintintID = curEnv->GetStaticMethodID(cls, "isUnwrappable", "(I)I" ) ;
-    if (jintisUnwrappablejintintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "isUnwrappable");
-    }
+int ScilabJavaObject::wrap (JavaVM * jvm_, double const* x, int xSize){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintisUnwrappablejintintID , id));
-    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 jintwrapjdoubleArray_doubledoubleID = curEnv->GetStaticMethodID(cls, "wrap", "([D)I" ) ;
+if (jintwrapjdoubleArray_doubledoubleID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, double x)
+jdoubleArray x_ = curEnv->NewDoubleArray( xSize ) ;
+
+if (x_ == NULL)
 {
+// check that allocation succeed
+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->SetDoubleArrayRegion( x_, 0, xSize, (jdouble*)(x) ) ;
 
-    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, jintwrapjdoubledoubleID , x));
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjdoubleArray_doubledoubleID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+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");
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, double const* x, int xSize)
+ 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++){
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+jdoubleArray xLocal = curEnv->NewDoubleArray( xSizeCol ) ;
 
-    static jmethodID jintwrapjdoubleArray_doubledoubleID = curEnv->GetStaticMethodID(cls, "wrap", "([D)I" ) ;
-    if (jintwrapjdoubleArray_doubledoubleID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+if (xLocal == NULL)
+{
+// check that allocation succeed
+curEnv->DeleteLocalRef(x_);
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    jdoubleArray x_ = curEnv->NewDoubleArray( xSize ) ;
+curEnv->SetDoubleArrayRegion( xLocal, 0, xSizeCol, (jdouble*)(x[i]) ) ;
+curEnv->SetObjectArrayElement(x_, i, xLocal);
+curEnv->DeleteLocalRef(xLocal);
+}
 
-    if (x_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__doubledoubleID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    curEnv->SetDoubleArrayRegion( x_, 0, xSize, (jdouble*)(x) ) ;
+}
 
+int ScilabJavaObject::wrap (JavaVM * jvm_, int x){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjdoubleArray_doubledoubleID , 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 = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+static jmethodID jintwrapjintintID = curEnv->GetStaticMethodID(cls, "wrap", "(I)I" ) ;
+if (jintwrapjintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, double const* const* x, int xSize, int xSizeCol)
-{
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjintintID ,x));
+                        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__doubledoubleID = curEnv->GetStaticMethodID(cls, "wrap", "([[D)I" ) ;
-    if (jintwrapjobjectArray__doubledoubleID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
-
-    jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[D"), NULL);
-
-    if (x_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
-
-    for (int i = 0; i < xSize; i++)
-    {
-
-        jdoubleArray xLocal = curEnv->NewDoubleArray( xSizeCol ) ;
-
-        if (xLocal == NULL)
-        {
-            // check that allocation succeed
-            curEnv->DeleteLocalRef(x_);
-            throw GiwsException::JniBadAllocException(curEnv);
-        }
+}
 
-        curEnv->SetDoubleArrayRegion( xLocal, 0, xSizeCol, (jdouble*)(x[i]) ) ;
-        curEnv->SetObjectArrayElement(x_, i, xLocal);
-        curEnv->DeleteLocalRef(xLocal);
-    }
+int ScilabJavaObject::wrap (JavaVM * jvm_, int const* x, int xSize){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__doubledoubleID , 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 = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+static jmethodID jintwrapjintArray_intintID = curEnv->GetStaticMethodID(cls, "wrap", "([I)I" ) ;
+if (jintwrapjintArray_intintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, int x)
+jintArray x_ = curEnv->NewIntArray( xSize ) ;
+
+if (x_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
+
+curEnv->SetIntArrayRegion( x_, 0, xSize, (jint*)(x) ) ;
+
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = initClass(curEnv);
-    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;
+
+}
 
-    static jmethodID jintwrapjintintID = curEnv->GetStaticMethodID(cls, "wrap", "(I)I" ) ;
-    if (jintwrapjintintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+int ScilabJavaObject::wrap (JavaVM * jvm_, int const* const* x, int xSize, int xSizeCol){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjintintID , x));
-    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__intintID = curEnv->GetStaticMethodID(cls, "wrap", "([[I)I" ) ;
+if (jintwrapjobjectArray__intintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, int const* x, int xSize)
+ jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[I"),NULL);
+
+if (x_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+ for (int i=0; i<xSize; i++){
 
-    static jmethodID jintwrapjintArray_intintID = curEnv->GetStaticMethodID(cls, "wrap", "([I)I" ) ;
-    if (jintwrapjintArray_intintID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+jintArray xLocal = curEnv->NewIntArray( xSizeCol ) ;
 
-    jintArray x_ = curEnv->NewIntArray( xSize ) ;
+if (xLocal == NULL)
+{
+// check that allocation succeed
+curEnv->DeleteLocalRef(x_);
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    if (x_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+curEnv->SetIntArrayRegion( xLocal, 0, xSizeCol, (jint*)(x[i]) ) ;
+curEnv->SetObjectArrayElement(x_, i, xLocal);
+curEnv->DeleteLocalRef(xLocal);
+}
 
-    curEnv->SetIntArrayRegion( x_, 0, xSize, (jint*)(x) ) ;
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__intintID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjintArray_intintID , x_));
-    curEnv->DeleteLocalRef(x_);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+int ScilabJavaObject::wrap (JavaVM * jvm_, byte x){
 
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, int 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 = 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);
-        }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbytebyteID ,x));
+                        if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
+
+}
 
-        curEnv->SetIntArrayRegion( xLocal, 0, xSizeCol, (jint*)(x[i]) ) ;
-        curEnv->SetObjectArrayElement(x_, i, xLocal);
-        curEnv->DeleteLocalRef(xLocal);
-    }
+int ScilabJavaObject::wrap (JavaVM * jvm_, byte const* x, int xSize){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__intintID , 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 = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+static jmethodID jintwrapjbyteArray_bytebyteID = curEnv->GetStaticMethodID(cls, "wrap", "([B)I" ) ;
+if (jintwrapjbyteArray_bytebyteID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, byte x)
+jbyteArray x_ = curEnv->NewByteArray( xSize ) ;
+
+if (x_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
+
+curEnv->SetByteArrayRegion( x_, 0, xSize, (jbyte*)(x) ) ;
+
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = initClass(curEnv);
-    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;
+
+}
 
-    static jmethodID jintwrapjbytebyteID = curEnv->GetStaticMethodID(cls, "wrap", "(B)I" ) ;
-    if (jintwrapjbytebyteID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+int ScilabJavaObject::wrap (JavaVM * jvm_, byte const* const* x, int xSize, int xSizeCol){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbytebyteID , x));
-    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__bytebyteID = curEnv->GetStaticMethodID(cls, "wrap", "([[B)I" ) ;
+if (jintwrapjobjectArray__bytebyteID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, byte const* x, int xSize)
+ jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[B"),NULL);
+
+if (x_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+ for (int i=0; i<xSize; i++){
 
-    static jmethodID jintwrapjbyteArray_bytebyteID = curEnv->GetStaticMethodID(cls, "wrap", "([B)I" ) ;
-    if (jintwrapjbyteArray_bytebyteID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+jbyteArray xLocal = curEnv->NewByteArray( xSizeCol ) ;
 
-    jbyteArray x_ = curEnv->NewByteArray( xSize ) ;
+if (xLocal == NULL)
+{
+// check that allocation succeed
+curEnv->DeleteLocalRef(x_);
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    if (x_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+curEnv->SetByteArrayRegion( xLocal, 0, xSizeCol, (jbyte*)(x[i]) ) ;
+curEnv->SetObjectArrayElement(x_, i, xLocal);
+curEnv->DeleteLocalRef(xLocal);
+}
 
-    curEnv->SetByteArrayRegion( x_, 0, xSize, (jbyte*)(x) ) ;
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__bytebyteID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbyteArray_bytebyteID , x_));
-    curEnv->DeleteLocalRef(x_);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+int ScilabJavaObject::wrap (JavaVM * jvm_, short x){
 
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, byte const* const* x, int xSize, int xSizeCol)
-{
+static jmethodID jintwrapjshortshortID = curEnv->GetStaticMethodID(cls, "wrap", "(S)I" ) ;
+if (jintwrapjshortshortID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = 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);
-        }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjshortshortID ,x));
+                        if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-        curEnv->SetByteArrayRegion( xLocal, 0, xSizeCol, (jbyte*)(x[i]) ) ;
-        curEnv->SetObjectArrayElement(x_, i, xLocal);
-        curEnv->DeleteLocalRef(xLocal);
-    }
+}
+
+int ScilabJavaObject::wrap (JavaVM * jvm_, short const* x, int xSize){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__bytebyteID , 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 = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+static jmethodID jintwrapjshortArray_shortshortID = curEnv->GetStaticMethodID(cls, "wrap", "([S)I" ) ;
+if (jintwrapjshortArray_shortshortID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, short x)
+jshortArray x_ = curEnv->NewShortArray( xSize ) ;
+
+if (x_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
+
+curEnv->SetShortArrayRegion( x_, 0, xSize, (jshort*)(x) ) ;
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
 
-    static jmethodID jintwrapjshortshortID = curEnv->GetStaticMethodID(cls, "wrap", "(S)I" ) ;
-    if (jintwrapjshortshortID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjshortArray_shortshortID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
+
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjshortshortID , x));
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+int ScilabJavaObject::wrap (JavaVM * jvm_, 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);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, short const* x, int xSize)
+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);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+ for (int i=0; i<xSize; i++){
 
-    static jmethodID jintwrapjshortArray_shortshortID = curEnv->GetStaticMethodID(cls, "wrap", "([S)I" ) ;
-    if (jintwrapjshortArray_shortshortID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+jshortArray xLocal = curEnv->NewShortArray( xSizeCol ) ;
 
-    jshortArray x_ = curEnv->NewShortArray( xSize ) ;
+if (xLocal == NULL)
+{
+// check that allocation succeed
+curEnv->DeleteLocalRef(x_);
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    if (x_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+curEnv->SetShortArrayRegion( xLocal, 0, xSizeCol, (jshort*)(x[i]) ) ;
+curEnv->SetObjectArrayElement(x_, i, xLocal);
+curEnv->DeleteLocalRef(xLocal);
+}
 
-    curEnv->SetShortArrayRegion( x_, 0, xSize, (jshort*)(x) ) ;
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__shortshortID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjshortArray_shortshortID , x_));
-    curEnv->DeleteLocalRef(x_);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+int ScilabJavaObject::wrap (JavaVM * jvm_, char const* 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_, short const* const* x, int xSize, int xSizeCol)
+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);
+}
 
-    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);
-        }
 
-        curEnv->SetShortArrayRegion( xLocal, 0, xSizeCol, (jshort*)(x[i]) ) ;
-        curEnv->SetObjectArrayElement(x_, i, xLocal);
-        curEnv->DeleteLocalRef(xLocal);
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjstringjava_lang_StringID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
+
+}
+
+int ScilabJavaObject::wrap (JavaVM * jvm_, char const* const* x, int xSize){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__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 = 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");
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, char const* x)
+// create java array of strings.
+jobjectArray x_ = curEnv->NewObjectArray( xSize, stringArrayClass, NULL);
+if (x_ == NULL)
 {
+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);
-    }
+// 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);
+}
 
-    static jmethodID jintwrapjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "wrap", "(Ljava/lang/String;)I" ) ;
-    if (jintwrapjstringjava_lang_StringID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+curEnv->SetObjectArrayElement( x_, i, TempString);
 
-    jstring x_ = curEnv->NewStringUTF( x );
-    if (x != NULL && x_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(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_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjstringjava_lang_StringID , x_));
-    curEnv->DeleteLocalRef(x_);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+int ScilabJavaObject::wrap (JavaVM * jvm_, char const* const* const* x, int xSize, int xSizeCol){
 
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, char const* const* x, int xSize)
+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);
+}
 
-    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);
-        }
+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] );
 
-        curEnv->SetObjectArrayElement( x_, i, TempString);
+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, jintwrapjobjectArray_java_lang_Stringjava_lang_StringID , x_));
-    curEnv->DeleteLocalRef(stringArrayClass);
-    curEnv->DeleteLocalRef(x_);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+curEnv->SetObjectArrayElement( xLocal, j, TempString);
 
+// avoid keeping reference on too many strings
+curEnv->DeleteLocalRef(TempString);
 }
+curEnv->SetObjectArrayElement(x_, i, xLocal);
+curEnv->DeleteLocalRef(xLocal);
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, char const* const* const* x, int xSize, int xSizeCol)
-{
+}
+                        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;
 
-    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);
+}
 
-    }
-    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 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_, bool x)
-{
+static 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);
-    }
+jboolean x_ = (static_cast<bool>(x) ? JNI_TRUE : JNI_FALSE);
 
-    static jmethodID jintwrapjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "wrap", "(Z)I" ) ;
-    if (jintwrapjbooleanbooleanID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbooleanbooleanID ,x_));
+                        if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    jboolean x_ = (static_cast<bool>(x) ? JNI_TRUE : JNI_FALSE);
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbooleanbooleanID , 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 = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, bool const* x, int xSize)
-{
+static 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);
-    }
+jbooleanArray x_ = curEnv->NewBooleanArray( xSize ) ;
+curEnv->SetBooleanArrayRegion( x_, 0, xSize, (jboolean*)x ) ;
 
-    static jmethodID jintwrapjbooleanArray_booleanbooleanID = curEnv->GetStaticMethodID(cls, "wrap", "([Z)I" ) ;
-    if (jintwrapjbooleanArray_booleanbooleanID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbooleanArray_booleanbooleanID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    jbooleanArray x_ = curEnv->NewBooleanArray( xSize ) ;
-    curEnv->SetBooleanArrayRegion( x_, 0, xSize, (jboolean*)x ) ;
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbooleanArray_booleanbooleanID , x_));
-    curEnv->DeleteLocalRef(x_);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+int ScilabJavaObject::wrap (JavaVM * jvm_, bool const* const* x, int xSize, int xSizeCol){
 
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, bool const* const* x, int xSize, int xSizeCol)
-{
+static jmethodID jintwrapjobjectArray__booleanbooleanID = curEnv->GetStaticMethodID(cls, "wrap", "([[Z)I" ) ;
+if (jintwrapjobjectArray__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__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)
-{
+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);
-    }
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+
+static jmethodID jintwrapjcharcharID = curEnv->GetStaticMethodID(cls, "wrap", "(C)I" ) ;
+if (jintwrapjcharcharID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+}
 
-    static jmethodID jintwrapjcharcharID = curEnv->GetStaticMethodID(cls, "wrap", "(C)I" ) ;
-    if (jintwrapjcharcharID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjcharcharID ,x));
+                        if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
+
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjcharcharID , x));
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+int ScilabJavaObject::wrap (JavaVM * jvm_, unsigned short const* x, int xSize){
 
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, unsigned short const* x, int xSize)
+static 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)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
+
+curEnv->SetCharArrayRegion( x_, 0, xSize, (jchar*)(x) ) ;
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
 
-    static jmethodID jintwrapjcharArray_charcharID = curEnv->GetStaticMethodID(cls, "wrap", "([C)I" ) ;
-    if (jintwrapjcharArray_charcharID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjcharArray_charcharID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    jcharArray x_ = curEnv->NewCharArray( xSize ) ;
+}
 
-    if (x_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+int ScilabJavaObject::wrap (JavaVM * jvm_, unsigned short const* const* x, int xSize, int xSizeCol){
 
-    curEnv->SetCharArrayRegion( x_, 0, xSize, (jchar*)(x) ) ;
+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");
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjcharArray_charcharID , x_));
-    curEnv->DeleteLocalRef(x_);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+ jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[C"),NULL);
 
+if (x_ == NULL)
+{
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, unsigned short const* const* x, int xSize, int xSizeCol)
+ for (int i=0; i<xSize; i++){
+
+jcharArray xLocal = curEnv->NewCharArray( xSizeCol ) ;
+
+if (xLocal == NULL)
 {
+// check that allocation succeed
+curEnv->DeleteLocalRef(x_);
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = 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);
-        }
+curEnv->SetCharArrayRegion( xLocal, 0, xSizeCol, (jchar*)(x[i]) ) ;
+curEnv->SetObjectArrayElement(x_, i, xLocal);
+curEnv->DeleteLocalRef(xLocal);
+}
+
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__charcharID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
+
+}
 
-        curEnv->SetCharArrayRegion( xLocal, 0, xSizeCol, (jchar*)(x[i]) ) ;
-        curEnv->SetObjectArrayElement(x_, i, xLocal);
-        curEnv->DeleteLocalRef(xLocal);
-    }
+int ScilabJavaObject::wrap (JavaVM * jvm_, float x){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__charcharID , 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 = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+static jmethodID jintwrapjfloatfloatID = curEnv->GetStaticMethodID(cls, "wrap", "(F)I" ) ;
+if (jintwrapjfloatfloatID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, float x)
-{
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjfloatfloatID ,x));
+                        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 jintwrapjfloatfloatID = curEnv->GetStaticMethodID(cls, "wrap", "(F)I" ) ;
-    if (jintwrapjfloatfloatID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+int ScilabJavaObject::wrap (JavaVM * jvm_, float const* x, int xSize){
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjfloatfloatID , x));
-    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 jintwrapjfloatArray_floatfloatID = curEnv->GetStaticMethodID(cls, "wrap", "([F)I" ) ;
+if (jintwrapjfloatArray_floatfloatID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, float const* x, int xSize)
+jfloatArray x_ = curEnv->NewFloatArray( xSize ) ;
+
+if (x_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
+
+curEnv->SetFloatArrayRegion( x_, 0, xSize, (jfloat*)(x) ) ;
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
 
-    static jmethodID jintwrapjfloatArray_floatfloatID = curEnv->GetStaticMethodID(cls, "wrap", "([F)I" ) ;
-    if (jintwrapjfloatArray_floatfloatID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjfloatArray_floatfloatID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-    jfloatArray x_ = curEnv->NewFloatArray( xSize ) ;
+}
 
-    if (x_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+int ScilabJavaObject::wrap (JavaVM * jvm_, float const* const* x, int xSize, int xSizeCol){
 
-    curEnv->SetFloatArrayRegion( x_, 0, xSize, (jfloat*)(x) ) ;
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = 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");
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjfloatArray_floatfloatID , x_));
-    curEnv->DeleteLocalRef(x_);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+ jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[F"),NULL);
 
+if (x_ == NULL)
+{
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, float const* const* x, int xSize, int xSizeCol)
+ for (int i=0; i<xSize; i++){
+
+jfloatArray xLocal = curEnv->NewFloatArray( xSizeCol ) ;
+
+if (xLocal == NULL)
 {
+// check that allocation succeed
+curEnv->DeleteLocalRef(x_);
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = 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);
-        }
+curEnv->SetFloatArrayRegion( xLocal, 0, xSizeCol, (jfloat*)(x[i]) ) ;
+curEnv->SetObjectArrayElement(x_, i, xLocal);
+curEnv->DeleteLocalRef(xLocal);
+}
+
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__floatfloatID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-        curEnv->SetFloatArrayRegion( xLocal, 0, xSizeCol, (jfloat*)(x[i]) ) ;
-        curEnv->SetObjectArrayElement(x_, i, xLocal);
-        curEnv->DeleteLocalRef(xLocal);
-    }
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__floatfloatID , x_));
-    curEnv->DeleteLocalRef(x_);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+int ScilabJavaObject::wrap (JavaVM * jvm_, long long x){
 
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, long long x)
-{
+static jmethodID jintwrapjlonglongID = curEnv->GetStaticMethodID(cls, "wrap", "(J)I" ) ;
+if (jintwrapjlonglongID == 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);
-    }
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjlonglongID ,x));
+                        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* x, int xSize){
 
-    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 = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
 
+static jmethodID jintwrapjlongArray_longlongID = curEnv->GetStaticMethodID(cls, "wrap", "([J)I" ) ;
+if (jintwrapjlongArray_longlongID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, long long const* x, int xSize)
+jlongArray x_ = curEnv->NewLongArray( xSize ) ;
+
+if (x_ == NULL)
 {
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = initClass(curEnv);
-    if ( cls == NULL)
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
+curEnv->SetLongArrayRegion( x_, 0, xSize, (jlong*)(x) ) ;
 
-    static jmethodID jintwrapjlongArray_longlongID = curEnv->GetStaticMethodID(cls, "wrap", "([J)I" ) ;
-    if (jintwrapjlongArray_longlongID == NULL)
-    {
-        throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
-    }
 
-    jlongArray x_ = curEnv->NewLongArray( xSize ) ;
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjlongArray_longlongID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
+
+}
 
-    if (x_ == NULL)
-    {
-        // check that allocation succeed
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+int ScilabJavaObject::wrap (JavaVM * jvm_, long long const* const* x, int xSize, int xSizeCol){
 
-    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);
+}
 
+static jmethodID jintwrapjobjectArray__longlongID = curEnv->GetStaticMethodID(cls, "wrap", "([[J)I" ) ;
+if (jintwrapjobjectArray__longlongID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjlongArray_longlongID , x_));
-    curEnv->DeleteLocalRef(x_);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+ jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[J"),NULL);
 
+if (x_ == NULL)
+{
+// check that allocation succeed
+throw GiwsException::JniBadAllocException(curEnv);
 }
 
-int ScilabJavaObject::wrap (JavaVM * jvm_, long long const* const* x, int xSize, int xSizeCol)
+ for (int i=0; i<xSize; i++){
+
+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 = 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);
-        }
+curEnv->SetLongArrayRegion( xLocal, 0, xSizeCol, (jlong*)(x[i]) ) ;
+curEnv->SetObjectArrayElement(x_, i, xLocal);
+curEnv->DeleteLocalRef(xLocal);
+}
+
+                        jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__longlongID ,x_));
+                        curEnv->DeleteLocalRef(x_);
+if (curEnv->ExceptionCheck()) {
+throw GiwsException::JniCallMethodException(curEnv);
+}
+return res;
 
-        curEnv->SetLongArrayRegion( xLocal, 0, xSizeCol, (jlong*)(x[i]) ) ;
-        curEnv->SetObjectArrayElement(x_, i, xLocal);
-        curEnv->DeleteLocalRef(xLocal);
-    }
+}
 
-    jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__longlongID , x_));
-    curEnv->DeleteLocalRef(x_);
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    return res;
+char** ScilabJavaObject::getAccessibleFields (JavaVM * jvm_, int id, int *lenRow){
 
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-char** ScilabJavaObject::getAccessibleFields (JavaVM * jvm_, int id, int *lenRow)
-{
+static jmethodID jobjectArray_getAccessibleFieldsjintintID = curEnv->GetStaticMethodID(cls, "getAccessibleFields", "(I)[Ljava/lang/String;" ) ;
+if (jobjectArray_getAccessibleFieldsjintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "getAccessibleFields");
+}
 
-    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;
-    }
+                        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;
+}
 }
 
-char** ScilabJavaObject::getAccessibleMethods (JavaVM * jvm_, int id, int *lenRow)
-{
+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 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;
-    }
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-char** ScilabJavaObject::getCompletion (JavaVM * jvm_, int id, char const* const* fieldPath, int fieldPathSize, int *lenRow)
+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;
+}
+}
+
+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 = 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);
+}
 
-    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);
-        }
+// convert each char * to java strings and fill the java array.
+for ( int i = 0; i < fieldPathSize; i++)
+{
+jstring TempString = curEnv->NewStringUTF( fieldPath[i] );
+if (TempString == NULL)
+{
+throw GiwsException::JniBadAllocException(curEnv);
+}
 
-        curEnv->SetObjectArrayElement( fieldPath_, i, TempString);
-
-        // avoid keeping reference on too many strings
-        curEnv->DeleteLocalRef(TempString);
-    }
-    jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID , id, fieldPath_));
-    if (curEnv->ExceptionCheck())
-    {
-        throw GiwsException::JniCallMethodException(curEnv);
-    }
-    if (res != NULL)
-    {
-        * lenRow = curEnv->GetArrayLength(res);
-
-        char **arrayOfString;
-        arrayOfString = new char *[*lenRow];
-        for (jsize i = 0; i < *lenRow; i++)
-        {
-            jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
-            const char *tempString = curEnv->GetStringUTFChars(resString, 0);
-            arrayOfString[i] = new char[strlen(tempString) + 1];
-
-            strcpy(arrayOfString[i], tempString);
-            curEnv->ReleaseStringUTFChars(resString, tempString);
-            curEnv->DeleteLocalRef(resString);
-        }
-        curEnv->DeleteLocalRef(stringArrayClass);
-        curEnv->DeleteLocalRef(fieldPath_);
-        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 1401d89..0b5fc1e 100644 (file)
@@ -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,267 +69,265 @@ typedef signed char byte;
 # endif
 #endif
 
-namespace org_scilab_modules_external_objects_java
-{
-class GIWSEXPORT ScilabJavaObject
-{
+namespace org_scilab_modules_external_objects_java {
+class GIWSEXPORT ScilabJavaObject {
 
 private:
-    JavaVM * jvm;
+JavaVM * jvm;
 
 protected:
-    jmethodID jintinvokejintintjstringjava_lang_StringjintArray_intintID; // cache method id
-    jmethodID jintextractjintintjintArray_intintID; // cache method id
-    jmethodID voidinsertjintintjintArray_intintjintintID; // cache method id
-    jmethodID jobjectArray_getInfosID; // cache method id
-    jmethodID voidinitScilabJavaObjectID; // cache method id
-    jmethodID voidgarbageCollectID; // cache method id
-    jmethodID jstringgetRepresentationjintintID; // cache method id
-    jmethodID jbooleanisValidJavaObjectjintintID; // cache method id
-    jmethodID voidenableTracejstringjava_lang_StringID; // cache method id
-    jmethodID voiddisableTraceID; // cache method id
-    jmethodID voidwriteLogjstringjava_lang_StringID; // cache method id
-    jmethodID voidsetFieldjintintjstringjava_lang_StringjintintID; // cache method id
-    jmethodID jintgetFieldjintintjstringjava_lang_StringID; // cache method id
-    jmethodID jintgetFieldTypejintintjstringjava_lang_StringID; // cache method id
-    jmethodID jintjavaCastjintintjstringjava_lang_StringID; // cache method id
-    jmethodID jintjavaCastjintintjintintID; // cache method id
-    jmethodID jstringgetClassNamejintintID; // cache method id
-    jmethodID jintgetArrayElementjintintjintArray_intintID; // cache method id
-    jmethodID voidsetArrayElementjintintjintArray_intintjintintID; // cache method id
-    jmethodID voidremoveScilabJavaObjectjintintID; // cache method id
-    jmethodID voidremoveScilabJavaObjectjintArray_intintID; // cache method id
-    jmethodID voidlimitDirectBufferjintintID; // cache method id
-    jmethodID jintisUnwrappablejintintID; // cache method id
-    jmethodID jintwrapjdoubledoubleID; // cache method id
-    jmethodID jintwrapjdoubleArray_doubledoubleID; // cache method id
-    jmethodID jintwrapjobjectArray__doubledoubleID; // cache method id
-    jmethodID jintwrapjintintID; // cache method id
-    jmethodID jintwrapjintArray_intintID; // cache method id
-    jmethodID jintwrapjobjectArray__intintID; // cache method id
-    jmethodID jintwrapjbytebyteID; // cache method id
-    jmethodID jintwrapjbyteArray_bytebyteID; // cache method id
-    jmethodID jintwrapjobjectArray__bytebyteID; // cache method id
-    jmethodID jintwrapjshortshortID; // cache method id
-    jmethodID jintwrapjshortArray_shortshortID; // cache method id
-    jmethodID jintwrapjobjectArray__shortshortID; // cache method id
-    jmethodID jintwrapjstringjava_lang_StringID; // cache method id
-    jmethodID jintwrapjobjectArray_java_lang_Stringjava_lang_StringID; // cache method id
-    jclass stringArrayClass;
-    jmethodID jintwrapjobjectArray__java_lang_Stringjava_lang_StringID; // cache method id
-    jmethodID jintwrapjbooleanbooleanID; // cache method id
-    jmethodID jintwrapjbooleanArray_booleanbooleanID; // cache method id
-    jmethodID jintwrapjobjectArray__booleanbooleanID; // cache method id
-    jmethodID jintwrapjcharcharID; // cache method id
-    jmethodID jintwrapjcharArray_charcharID; // cache method id
-    jmethodID jintwrapjobjectArray__charcharID; // cache method id
-    jmethodID jintwrapjfloatfloatID; // cache method id
-    jmethodID jintwrapjfloatArray_floatfloatID; // cache method id
-    jmethodID jintwrapjobjectArray__floatfloatID; // cache method id
-    jmethodID jintwrapjlonglongID; // cache method id
-    jmethodID jintwrapjlongArray_longlongID; // cache method id
-    jmethodID jintwrapjobjectArray__longlongID; // cache method id
-    jmethodID jobjectArray_getAccessibleFieldsjintintID; // cache method id
-    jmethodID jobjectArray_getAccessibleMethodsjintintID; // cache method id
-    jmethodID jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID; // cache method id
-
-
-
-    jobject instance;
-    jclass instanceClass; // cache class
-
-
-    // Caching (if any)
-
-
-    /**
-    * Get the environment matching to the current thread.
-    */
-    virtual JNIEnv * getCurrentEnv();
+jmethodID jintinvokejintintjstringjava_lang_StringjintArray_intintID; // cache method id
+jmethodID jintextractjintintjintArray_intintID; // cache method id
+jmethodID voidinsertjintintjintArray_intintjintintID; // cache method id
+jmethodID jobjectArray_getInfosID; // cache method id
+jmethodID voidinitScilabJavaObjectID; // cache method id
+jmethodID voidgarbageCollectID; // cache method id
+jmethodID jstringgetRepresentationjintintID; // cache method id
+jmethodID jbooleanisValidJavaObjectjintintID; // cache method id
+jmethodID voidenableTracejstringjava_lang_StringID; // cache method id
+jmethodID voiddisableTraceID; // cache method id
+jmethodID voidwriteLogjstringjava_lang_StringID; // cache method id
+jmethodID voidsetFieldjintintjstringjava_lang_StringjintintID; // cache method id
+jmethodID jintgetFieldjintintjstringjava_lang_StringID; // cache method id
+jmethodID jintgetFieldTypejintintjstringjava_lang_StringID; // cache method id
+jmethodID jintjavaCastjintintjstringjava_lang_StringID; // cache method id
+jmethodID jintjavaCastjintintjintintID; // cache method id
+jmethodID jstringgetClassNamejintintID; // cache method id
+jmethodID jintgetArrayElementjintintjintArray_intintID; // cache method id
+jmethodID voidsetArrayElementjintintjintArray_intintjintintID; // cache method id
+jmethodID voidremoveScilabJavaObjectjintintID; // cache method id
+jmethodID voidremoveScilabJavaObjectjintArray_intintID; // cache method id
+jmethodID voidlimitDirectBufferjintintID; // cache method id
+jmethodID jintisUnwrappablejintintID; // cache method id
+jmethodID jintwrapjdoubledoubleID; // cache method id
+jmethodID jintwrapjdoubleArray_doubledoubleID; // cache method id
+jmethodID jintwrapjobjectArray__doubledoubleID; // cache method id
+jmethodID jintwrapjintintID; // cache method id
+jmethodID jintwrapjintArray_intintID; // cache method id
+jmethodID jintwrapjobjectArray__intintID; // cache method id
+jmethodID jintwrapjbytebyteID; // cache method id
+jmethodID jintwrapjbyteArray_bytebyteID; // cache method id
+jmethodID jintwrapjobjectArray__bytebyteID; // cache method id
+jmethodID jintwrapjshortshortID; // cache method id
+jmethodID jintwrapjshortArray_shortshortID; // cache method id
+jmethodID jintwrapjobjectArray__shortshortID; // cache method id
+jmethodID jintwrapjstringjava_lang_StringID; // cache method id
+jmethodID jintwrapjobjectArray_java_lang_Stringjava_lang_StringID; // cache method id
+jclass stringArrayClass;
+jmethodID jintwrapjobjectArray__java_lang_Stringjava_lang_StringID; // cache method id
+jmethodID jintwrapjbooleanbooleanID; // cache method id
+jmethodID jintwrapjbooleanArray_booleanbooleanID; // cache method id
+jmethodID jintwrapjobjectArray__booleanbooleanID; // cache method id
+jmethodID jintwrapjcharcharID; // cache method id
+jmethodID jintwrapjcharArray_charcharID; // cache method id
+jmethodID jintwrapjobjectArray__charcharID; // cache method id
+jmethodID jintwrapjfloatfloatID; // cache method id
+jmethodID jintwrapjfloatArray_floatfloatID; // cache method id
+jmethodID jintwrapjobjectArray__floatfloatID; // cache method id
+jmethodID jintwrapjlonglongID; // cache method id
+jmethodID jintwrapjlongArray_longlongID; // cache method id
+jmethodID jintwrapjobjectArray__longlongID; // cache method id
+jmethodID jobjectArray_getAccessibleFieldsjintintID; // cache method id
+jmethodID jobjectArray_getAccessibleMethodsjintintID; // cache method id
+jmethodID jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID; // cache method id
+
+
+
+jobject instance;
+jclass instanceClass; // cache class
+
+                       
+// Caching (if any)
+
+
+/**
+* Get the environment matching to the current thread.
+*/
+virtual JNIEnv * getCurrentEnv();
 
 public:
-    // Constructor
-    /**
-    * Create a wrapping of the object from a JNIEnv.
-    * It will call the default constructor
-    * @param JEnv_ the Java Env
-    */
-    ScilabJavaObject(JavaVM * jvm_);
-
-    /**
-    * Create a wrapping of an already existing object from a JNIEnv.
-    * The object must have already been instantiated
-    * @param JEnv_ the Java Env
-    * @param JObj the object
-    */
-    ScilabJavaObject(JavaVM * jvm_, jobject JObj);
-
-
-    /**
-    * This is a fake constructor to avoid the constructor
-    * chaining when dealing with extended giws classes
-    */
-#ifdef FAKEGIWSDATATYPE
-    ScilabJavaObject(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
-#endif
-
-    // Destructor
-    ~ScilabJavaObject();
+// Constructor
+/**
+* Create a wrapping of the object from a JNIEnv.
+* It will call the default constructor
+* @param JEnv_ the Java Env
+*/
+ScilabJavaObject(JavaVM * jvm_);
 
-    // Generic method
-    // Synchronization methods
-    /**
-    * Enter monitor associated with the object.
-    * Equivalent of creating a "synchronized(obj)" scope in Java.
-    */
-    void synchronize();
+/**
+* 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);
 
-    /**
-    * Exit monitor associated with the object.
-    * Equivalent of ending a "synchronized(obj)" scope.
-    */
-    void endSynchronize();
 
-    // Methods
-    static int invoke(JavaVM * jvm_, int id, char const* methodName, int const* args, int argsSize);
+/** 
+* This is a fake constructor to avoid the constructor
+* chaining when dealing with extended giws classes 
+*/
+#ifdef FAKEGIWSDATATYPE
+ScilabJavaObject(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
+#endif
 
-    static int extract(JavaVM * jvm_, int id, int const* args, int argsSize);
+// Destructor
+~ScilabJavaObject();
 
-    static void insert(JavaVM * jvm_, int id, int const* keys, int keysSize, int value);
+// Generic method
+// Synchronization methods
+/**
+* Enter monitor associated with the object.
+* Equivalent of creating a "synchronized(obj)" scope in Java.
+*/
+void synchronize();
 
-    static char** getInfos(JavaVM * jvm_, int *lenRow);
+/**
+* Exit monitor associated with the object.
+* Equivalent of ending a "synchronized(obj)" scope.
+*/
+void endSynchronize();
 
-    static void initScilabJavaObject(JavaVM * jvm_);
+// Methods
+static int invoke(JavaVM * jvm_, int id, char const* methodName, int const* args, int argsSize);
 
-    static void garbageCollect(JavaVM * jvm_);
+static int extract(JavaVM * jvm_, int id, int const* args, int argsSize);
 
-    static char* getRepresentation(JavaVM * jvm_, int id);
+static void insert(JavaVM * jvm_, int id, int const* keys, int keysSize, int value);
 
-    static bool isValidJavaObject(JavaVM * jvm_, int id);
+static char** getInfos(JavaVM * jvm_, int *lenRow);
 
-    static void enableTrace(JavaVM * jvm_, char const* filename);
+static void initScilabJavaObject(JavaVM * jvm_);
 
-    static void disableTrace(JavaVM * jvm_);
+static void garbageCollect(JavaVM * jvm_);
 
-    static void writeLog(JavaVM * jvm_, char const* s);
+static char* getRepresentation(JavaVM * jvm_, int id);
 
-    static void setField(JavaVM * jvm_, int id, char const* fieldName, int idarg);
+static bool isValidJavaObject(JavaVM * jvm_, int id);
 
-    static int getField(JavaVM * jvm_, int id, char const* fieldName);
+static void enableTrace(JavaVM * jvm_, char const* filename);
 
-    static int getFieldType(JavaVM * jvm_, int id, char const* fieldName);
+static void disableTrace(JavaVM * jvm_);
 
-    static int javaCast(JavaVM * jvm_, int id, char const* objName);
+static void writeLog(JavaVM * jvm_, char const* s);
 
-    static int javaCast(JavaVM * jvm_, int id, int classId);
+static void setField(JavaVM * jvm_, int id, char const* fieldName, int idarg);
 
-    static char* getClassName(JavaVM * jvm_, int id);
+static int getField(JavaVM * jvm_, int id, char const* fieldName);
 
-    static int getArrayElement(JavaVM * jvm_, int id, int const* index, int indexSize);
+static int getFieldType(JavaVM * jvm_, int id, char const* fieldName);
 
-    static void setArrayElement(JavaVM * jvm_, int id, int const* index, int indexSize, int idArg);
+static int javaCast(JavaVM * jvm_, int id, char const* objName);
 
-    static void removeScilabJavaObject(JavaVM * jvm_, int id);
+static int javaCast(JavaVM * jvm_, int id, int classId);
 
-    static void removeScilabJavaObject(JavaVM * jvm_, int const* id, int idSize);
+static char* getClassName(JavaVM * jvm_, int id);
 
-    static void limitDirectBuffer(JavaVM * jvm_, int id);
+static int getArrayElement(JavaVM * jvm_, int id, int const* index, int indexSize);
 
-    static int isUnwrappable(JavaVM * jvm_, int id);
+static void setArrayElement(JavaVM * jvm_, int id, int const* index, int indexSize, int idArg);
 
-    static int wrap(JavaVM * jvm_, double x);
+static void removeScilabJavaObject(JavaVM * jvm_, int id);
 
-    static int wrap(JavaVM * jvm_, double const* x, int xSize);
+static void removeScilabJavaObject(JavaVM * jvm_, int const* id, int idSize);
 
-    static int wrap(JavaVM * jvm_, double const* const* x, int xSize, int xSizeCol);
+static void limitDirectBuffer(JavaVM * jvm_, int id);
 
-    static int wrap(JavaVM * jvm_, int x);
+static int isUnwrappable(JavaVM * jvm_, int id);
 
-    static int wrap(JavaVM * jvm_, int const* x, int xSize);
+static int wrap(JavaVM * jvm_, double x);
 
-    static int wrap(JavaVM * jvm_, int const* const* x, int xSize, int xSizeCol);
+static int wrap(JavaVM * jvm_, double const* x, int xSize);
 
-    static int wrap(JavaVM * jvm_, byte x);
+static int wrap(JavaVM * jvm_, double const* const* x, int xSize, int xSizeCol);
 
-    static int wrap(JavaVM * jvm_, byte const* x, int xSize);
+static int wrap(JavaVM * jvm_, int x);
 
-    static int wrap(JavaVM * jvm_, byte const* const* x, int xSize, int xSizeCol);
+static int wrap(JavaVM * jvm_, int const* x, int xSize);
 
-    static int wrap(JavaVM * jvm_, short x);
+static int wrap(JavaVM * jvm_, int const* const* x, int xSize, int xSizeCol);
 
-    static int wrap(JavaVM * jvm_, short const* x, int xSize);
+static int wrap(JavaVM * jvm_, byte x);
 
-    static int wrap(JavaVM * jvm_, short const* const* x, int xSize, int xSizeCol);
+static int wrap(JavaVM * jvm_, byte const* x, int xSize);
 
-    static int wrap(JavaVM * jvm_, char const* x);
+static int wrap(JavaVM * jvm_, byte const* const* x, int xSize, int xSizeCol);
 
-    static int wrap(JavaVM * jvm_, char const* const* x, int xSize);
+static int wrap(JavaVM * jvm_, short x);
 
-    static int wrap(JavaVM * jvm_, char const* const* const* x, int xSize, int xSizeCol);
+static int wrap(JavaVM * jvm_, short const* x, int xSize);
 
-    static int wrap(JavaVM * jvm_, bool x);
+static int wrap(JavaVM * jvm_, short const* const* x, int xSize, int xSizeCol);
 
-    static int wrap(JavaVM * jvm_, bool const* x, int xSize);
+static int wrap(JavaVM * jvm_, char const* x);
 
-    static int wrap(JavaVM * jvm_, bool const* const* x, int xSize, int xSizeCol);
+static int wrap(JavaVM * jvm_, char const* const* x, int xSize);
 
-    static int wrap(JavaVM * jvm_, unsigned short x);
+static int wrap(JavaVM * jvm_, char const* const* const* x, int xSize, int xSizeCol);
 
-    static int wrap(JavaVM * jvm_, unsigned short const* x, int xSize);
+static int wrap(JavaVM * jvm_, bool x);
 
-    static int wrap(JavaVM * jvm_, unsigned short const* const* x, int xSize, int xSizeCol);
+static int wrap(JavaVM * jvm_, bool const* x, int xSize);
 
-    static int wrap(JavaVM * jvm_, float x);
+static int wrap(JavaVM * jvm_, bool const* const* x, int xSize, int xSizeCol);
 
-    static int wrap(JavaVM * jvm_, float const* x, int xSize);
+static int wrap(JavaVM * jvm_, unsigned short x);
 
-    static int wrap(JavaVM * jvm_, float const* const* x, int xSize, int xSizeCol);
+static int wrap(JavaVM * jvm_, unsigned short const* x, int xSize);
 
-    static int wrap(JavaVM * jvm_, long long x);
+static int wrap(JavaVM * jvm_, unsigned short const* const* x, int xSize, int xSizeCol);
 
-    static int wrap(JavaVM * jvm_, long long const* x, int xSize);
+static int wrap(JavaVM * jvm_, float x);
 
-    static int wrap(JavaVM * jvm_, long long const* const* x, int xSize, int xSizeCol);
+static int wrap(JavaVM * jvm_, float const* x, int xSize);
 
-    static char** getAccessibleFields(JavaVM * jvm_, int id, int *lenRow);
+static int wrap(JavaVM * jvm_, float const* const* x, int xSize, int xSizeCol);
 
-    static char** getAccessibleMethods(JavaVM * jvm_, int id, int *lenRow);
+static int wrap(JavaVM * jvm_, long long x);
 
-    static char** getCompletion(JavaVM * jvm_, int id, char const* const* fieldPath, int fieldPathSize, int *lenRow);
+static int wrap(JavaVM * jvm_, long long const* x, int xSize);
 
+static int wrap(JavaVM * jvm_, long long const* const* x, int xSize, int xSizeCol);
 
-    /**
-    * Get class name to use for static methods
-    * @return class name to use for static methods
-    */
+static char** getAccessibleFields(JavaVM * jvm_, int id, int *lenRow);
 
-    static const std::string className()
-    {
-        return "org/scilab/modules/external_objects_java/ScilabJavaObject";
-    }
+static char** getAccessibleMethods(JavaVM * jvm_, int id, int *lenRow);
 
+static char** getCompletion(JavaVM * jvm_, int id, char const* const* fieldPath, int fieldPathSize, int *lenRow);
 
-    /**
-    * Get class to use for static methods
-    * @return class to use for static methods
-    */
 
-    static jclass initClass(JNIEnv * curEnv)
-    {
-        static jclass cls = 0;
+                        /**
+                        * 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";
+                }
+                
 
-        if (cls == 0)
-        {
-            jclass _cls = curEnv->FindClass(className().c_str());
-            if (_cls)
-            {
-                cls = static_cast<jclass>(curEnv->NewGlobalRef(_cls));
-            }
-        }
+                        /**
+                        * Get class to use for static methods
+                        * @return class to use for static methods
+                        */
+                        
+                static jclass initClass(JNIEnv * curEnv)
+                {
+                    static jclass cls = 0;
 
-        return cls;
-    }
+                    if (cls == 0)
+                    {
+                        jclass _cls = curEnv->FindClass(className().c_str());
+                        if (_cls)
+                        {
+                            cls = static_cast<jclass>(curEnv->NewGlobalRef(_cls));
+                        }
+                    }
 
+                    return cls;
+                 }
+                
 };
 
 
index 1ecfb0d..01cb437 100644 (file)
@@ -36,156 +36,135 @@ The fact that you are presently reading this means that you have had
 knowledge of the CeCILL-B license and that you accept its terms.
 */
 
-namespace org_scilab_modules_external_objects_java
-{
-
-// Static declarations (if any)
+namespace org_scilab_modules_external_objects_java {
 
+                // Static declarations (if any)
+                
 // Returns the current env
 
-JNIEnv * ScilabOperations::getCurrentEnv()
-{
-    JNIEnv * curEnv = NULL;
-    jint res = this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    if (res != JNI_OK)
-    {
-        throw GiwsException::JniException(getCurrentEnv());
-    }
-    return curEnv;
+JNIEnv * ScilabOperations::getCurrentEnv() {
+JNIEnv * curEnv = NULL;
+jint res=this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+if (res != JNI_OK) {
+throw GiwsException::JniException(getCurrentEnv());
+}
+return curEnv;
 }
 // Destructor
 
-ScilabOperations::~ScilabOperations()
-{
-    JNIEnv * curEnv = NULL;
-    this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    curEnv->DeleteGlobalRef(this->instance);
-    curEnv->DeleteGlobalRef(this->instanceClass);
+ScilabOperations::~ScilabOperations() {
+JNIEnv * curEnv = NULL;
+this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+curEnv->DeleteGlobalRef(this->instance);
+curEnv->DeleteGlobalRef(this->instanceClass);
 }
 // Constructors
-ScilabOperations::ScilabOperations(JavaVM * jvm_)
-{
-    jmethodID constructObject = NULL ;
-    jobject localInstance ;
-    jclass localClass ;
+ScilabOperations::ScilabOperations(JavaVM * jvm_) {
+jmethodID constructObject = NULL ;
+jobject localInstance ;
+jclass localClass ;
 
-    const std::string construct = "<init>";
-    const std::string param = "()V";
-    jvm = jvm_;
+const std::string construct="<init>";
+const std::string param="()V";
+jvm=jvm_;
 
-    JNIEnv * curEnv = getCurrentEnv();
+JNIEnv * curEnv = getCurrentEnv();
 
-    localClass = curEnv->FindClass( this->className().c_str() ) ;
-    if (localClass == NULL)
-    {
-        throw GiwsException::JniClassNotFoundException(curEnv, this->className());
-    }
-
-    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+localClass = curEnv->FindClass( this->className().c_str() ) ;
+if (localClass == NULL) {
+  throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+}
 
-    /* localClass is not needed anymore */
-    curEnv->DeleteLocalRef(localClass);
+this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
 
-    if (this->instanceClass == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+/* localClass is not needed anymore */
+curEnv->DeleteLocalRef(localClass);
 
+if (this->instanceClass == NULL) {
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
-    if (constructObject == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
 
-    localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
-    if (localInstance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
+if(constructObject == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    this->instance = curEnv->NewGlobalRef(localInstance) ;
-    if (this->instance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-    /* localInstance not needed anymore */
-    curEnv->DeleteLocalRef(localInstance);
+localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
+if(localInstance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+this->instance = curEnv->NewGlobalRef(localInstance) ;
+if(this->instance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+/* localInstance not needed anymore */
+curEnv->DeleteLocalRef(localInstance);
 
-    /* Methods ID set to NULL */
-    jintaddjintintjintintID = NULL;
+                /* Methods ID set to NULL */
+jintaddjintintjintintID=NULL;
 
 
 }
 
-ScilabOperations::ScilabOperations(JavaVM * jvm_, jobject JObj)
-{
-    jvm = jvm_;
+ScilabOperations::ScilabOperations(JavaVM * jvm_, jobject JObj) {
+        jvm=jvm_;
 
-    JNIEnv * curEnv = getCurrentEnv();
+        JNIEnv * curEnv = getCurrentEnv();
 
-    jclass localClass = curEnv->GetObjectClass(JObj);
-    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
-    curEnv->DeleteLocalRef(localClass);
+jclass localClass = curEnv->GetObjectClass(JObj);
+        this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+        curEnv->DeleteLocalRef(localClass);
 
-    if (this->instanceClass == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+        if (this->instanceClass == NULL) {
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+        }
 
-    this->instance = curEnv->NewGlobalRef(JObj) ;
-    if (this->instance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-    /* Methods ID set to NULL */
-    jintaddjintintjintintID = NULL;
+        this->instance = curEnv->NewGlobalRef(JObj) ;
+        if(this->instance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+        }
+        /* Methods ID set to NULL */
+        jintaddjintintjintintID=NULL;
 
 
 }
 
 // Generic methods
 
-void ScilabOperations::synchronize()
-{
-    if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK)
-    {
-        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabOperations");
-    }
+void ScilabOperations::synchronize() {
+if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
+throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabOperations");
+}
 }
 
-void ScilabOperations::endSynchronize()
-{
-    if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK)
-    {
-        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabOperations");
-    }
+void ScilabOperations::endSynchronize() {
+if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
+throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabOperations");
+}
 }
 // Method(s)
 
-int ScilabOperations::add (JavaVM * jvm_, int idA, int idB)
-{
-
-    JNIEnv * curEnv = NULL;
-    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-    jclass cls = 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;
+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 0bb4abb..2d16d88 100644 (file)
@@ -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,108 @@ typedef signed char byte;
 # endif
 #endif
 
-namespace org_scilab_modules_external_objects_java
-{
-class GIWSEXPORT ScilabOperations
-{
+namespace org_scilab_modules_external_objects_java {
+class GIWSEXPORT ScilabOperations {
 
 private:
-    JavaVM * jvm;
+JavaVM * jvm;
 
 protected:
-    jmethodID jintaddjintintjintintID; // cache method id
-
+jmethodID jintaddjintintjintintID; // cache method id
 
 
-    jobject instance;
-    jclass instanceClass; // cache class
 
+jobject instance;
+jclass instanceClass; // cache class
 
-    // Caching (if any)
+                       
+// Caching (if any)
 
 
-    /**
-    * Get the environment matching to the current thread.
-    */
-    virtual JNIEnv * getCurrentEnv();
+/**
+* Get the environment matching to the current thread.
+*/
+virtual JNIEnv * getCurrentEnv();
 
 public:
-    // Constructor
-    /**
-    * Create a wrapping of the object from a JNIEnv.
-    * It will call the default constructor
-    * @param JEnv_ the Java Env
-    */
-    ScilabOperations(JavaVM * jvm_);
-
-    /**
-    * Create a wrapping of an already existing object from a JNIEnv.
-    * The object must have already been instantiated
-    * @param JEnv_ the Java Env
-    * @param JObj the object
-    */
-    ScilabOperations(JavaVM * jvm_, jobject JObj);
-
-
-    /**
-    * This is a fake constructor to avoid the constructor
-    * chaining when dealing with extended giws classes
-    */
-#ifdef FAKEGIWSDATATYPE
-    ScilabOperations(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
-#endif
-
-    // Destructor
-    ~ScilabOperations();
-
-    // Generic method
-    // Synchronization methods
-    /**
-    * Enter monitor associated with the object.
-    * Equivalent of creating a "synchronized(obj)" scope in Java.
-    */
-    void synchronize();
-
-    /**
-    * 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";
-    }
+// 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);
 
-    /**
-    * Get class to use for static methods
-    * @return class to use for static methods
-    */
 
-    static jclass initClass(JNIEnv * curEnv)
-    {
-        static jclass cls = 0;
+/** 
+* This is a fake constructor to avoid the constructor
+* chaining when dealing with extended giws classes 
+*/
+#ifdef FAKEGIWSDATATYPE
+ScilabOperations(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
+#endif
 
-        if (cls == 0)
-        {
-            jclass _cls = curEnv->FindClass(className().c_str());
-            if (_cls)
-            {
-                cls = static_cast<jclass>(curEnv->NewGlobalRef(_cls));
-            }
-        }
+// Destructor
+~ScilabOperations();
 
-        return cls;
-    }
+// 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 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 fdc252e..209dc72 100644 (file)
@@ -36,291 +36,248 @@ 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
-{
-
-// Static declarations (if any)
+namespace org_scilab_modules_graphic_export {
 
+                // 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());
-    }
-
-    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+localClass = curEnv->FindClass( this->className().c_str() ) ;
+if (localClass == NULL) {
+  throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+}
 
-    /* localClass is not needed anymore */
-    curEnv->DeleteLocalRef(localClass);
+this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
 
-    if (this->instanceClass == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+/* localClass is not needed anymore */
+curEnv->DeleteLocalRef(localClass);
 
+if (this->instanceClass == NULL) {
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
-    if (constructObject == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
 
-    localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
-    if (localInstance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
+if(constructObject == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    this->instance = curEnv->NewGlobalRef(localInstance) ;
-    if (this->instance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-    /* localInstance not needed anymore */
-    curEnv->DeleteLocalRef(localInstance);
+localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
+if(localInstance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+this->instance = curEnv->NewGlobalRef(localInstance) ;
+if(this->instance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+/* localInstance not needed anymore */
+curEnv->DeleteLocalRef(localInstance);
 
-    /* Methods ID set to NULL */
-    jbooleansetDriverjstringjava_lang_StringID = NULL;
-    jstringgetDriverID = NULL;
-    voidsetPathjstringjava_lang_StringID = NULL;
-    jstringendjintintID = NULL;
+                /* 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)
+bool Driver::setDriver (JavaVM * jvm_, char const* driver){
+
+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);
+}
 
-    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");
-    }
+                        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);
 
-    jstring driver_ = curEnv->NewStringUTF( driver );
-    if (driver != NULL && driver_ == NULL)
-    {
-        throw GiwsException::JniBadAllocException(curEnv);
-    }
+}
 
+char* Driver::getDriver (JavaVM * jvm_){
 
-    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 = 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");
 }
 
-char* Driver::getDriver (JavaVM * jvm_)
-{
+                        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;
+}
+}
 
-    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;
-    }
+void Driver::setPath (JavaVM * jvm_, char const* path){
+
+JNIEnv * curEnv = NULL;
+jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+jclass cls = initClass(curEnv);
+if ( cls == NULL) {
+throw GiwsException::JniCallMethodException(curEnv);
 }
 
-void Driver::setPath (JavaVM * jvm_, char const* path)
-{
+static 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);
-    }
+jstring path_ = curEnv->NewStringUTF( path );
+if (path != NULL && path_ == NULL)
+{
+throw GiwsException::JniBadAllocException(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){
 
-    curEnv->CallStaticVoidMethod(cls, voidsetPathjstringjava_lang_StringID , path_);
-    curEnv->DeleteLocalRef(path_);
-    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* Driver::end (JavaVM * jvm_, int uid)
-{
+static jmethodID jstringendjintintID = curEnv->GetStaticMethodID(cls, "end", "(I)Ljava/lang/String;" ) ;
+if (jstringendjintintID == NULL) {
+throw GiwsException::JniMethodNotFoundException(curEnv, "end");
+}
 
-    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;
-    }
+                        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 74d8770..3ede686 100644 (file)
@@ -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,119 +69,117 @@ typedef signed char byte;
 # 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_);
-
-    /**
-    * 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
-
-    // Destructor
-    ~Driver();
-
-    // 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 bool setDriver(JavaVM * jvm_, char const* driver);
-
-    static char* getDriver(JavaVM * jvm_);
-
-    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";
-    }
+// 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);
 
-    /**
-    * Get class to use for static methods
-    * @return class to use for static methods
-    */
 
-    static jclass initClass(JNIEnv * curEnv)
-    {
-        static jclass cls = 0;
+/** 
+* This is a fake constructor to avoid the constructor
+* chaining when dealing with extended giws classes 
+*/
+#ifdef FAKEGIWSDATATYPE
+Driver(fakeGiwsDataType::fakeGiwsDataType /* unused */) {}
+#endif
 
-        if (cls == 0)
-        {
-            jclass _cls = curEnv->FindClass(className().c_str());
-            if (_cls)
-            {
-                cls = static_cast<jclass>(curEnv->NewGlobalRef(_cls));
-            }
-        }
+// Destructor
+~Driver();
 
-        return cls;
-    }
+// 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 bool setDriver(JavaVM * jvm_, char const* driver);
+
+static char* getDriver(JavaVM * jvm_);
+
+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";
+                }
+                
+
+                        /**
+                        * 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 2c6bd3c..8d03b1f 100644 (file)
@@ -36,183 +36,157 @@ 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
-{
-
-// Static declarations (if any)
+namespace org_scilab_modules_graphic_export {
 
+                // 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());
-    }
-
-    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+localClass = curEnv->FindClass( this->className().c_str() ) ;
+if (localClass == NULL) {
+  throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+}
 
-    /* localClass is not needed anymore */
-    curEnv->DeleteLocalRef(localClass);
+this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
 
-    if (this->instanceClass == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+/* localClass is not needed anymore */
+curEnv->DeleteLocalRef(localClass);
 
+if (this->instanceClass == NULL) {
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
-    if (constructObject == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
 
-    localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
-    if (localInstance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
+constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
+if(constructObject == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
 
-    this->instance = curEnv->NewGlobalRef(localInstance) ;
-    if (this->instance == NULL)
-    {
-        throw GiwsException::JniObjectCreationException(curEnv, this->className());
-    }
-    /* localInstance not needed anymore */
-    curEnv->DeleteLocalRef(localInstance);
+localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
+if(localInstance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+this->instance = curEnv->NewGlobalRef(localInstance) ;
+if(this->instance == NULL){
+throw GiwsException::JniObjectCreationException(curEnv, this->className());
+}
+/* localInstance not needed anymore */
+curEnv->DeleteLocalRef(localInstance);
 
-    /* Methods ID set to NULL */
-    jstringfileExportjintintjstringjava_lang_StringjintintjfloatfloatjintintID = NULL;
+                /* Methods ID set to NULL