Xcos MVC: add a default explorer view
[scilab.git] / scilab / modules / xcos / src / jni / JavaController_wrap.cxx
1 /* ----------------------------------------------------------------------------
2  * This file was automatically generated by SWIG (http://www.swig.org).
3  * Version 3.0.7
4  *
5  * This file is not intended to be easily readable and contains a number of
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG
8  * interface file instead.
9  * ----------------------------------------------------------------------------- */
10
11 #define SWIGJAVA
12 #define SWIG_DIRECTORS
13
14
15 #ifdef __cplusplus
16 /* SwigValueWrapper is described in swig.swg */
17 template<typename T> class SwigValueWrapper {
18   struct SwigMovePointer {
19     T *ptr;
20     SwigMovePointer(T *p) : ptr(p) { }
21     ~SwigMovePointer() { delete ptr; }
22     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
23   } pointer;
24   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
25   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
26 public:
27   SwigValueWrapper() : pointer(0) { }
28   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
29   operator T&() const { return *pointer.ptr; }
30   T *operator&() { return pointer.ptr; }
31 };
32
33 template <typename T> T SwigValueInit() {
34   return T();
35 }
36 #endif
37
38 /* -----------------------------------------------------------------------------
39  *  This section contains generic SWIG labels for method/variable
40  *  declarations/attributes, and other compiler dependent labels.
41  * ----------------------------------------------------------------------------- */
42
43 /* template workaround for compilers that cannot correctly implement the C++ standard */
44 #ifndef SWIGTEMPLATEDISAMBIGUATOR
45 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
46 #  define SWIGTEMPLATEDISAMBIGUATOR template
47 # elif defined(__HP_aCC)
48 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
49 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
50 #  define SWIGTEMPLATEDISAMBIGUATOR template
51 # else
52 #  define SWIGTEMPLATEDISAMBIGUATOR
53 # endif
54 #endif
55
56 /* inline attribute */
57 #ifndef SWIGINLINE
58 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
59 #   define SWIGINLINE inline
60 # else
61 #   define SWIGINLINE
62 # endif
63 #endif
64
65 /* attribute recognised by some compilers to avoid 'unused' warnings */
66 #ifndef SWIGUNUSED
67 # if defined(__GNUC__)
68 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
69 #     define SWIGUNUSED __attribute__ ((__unused__))
70 #   else
71 #     define SWIGUNUSED
72 #   endif
73 # elif defined(__ICC)
74 #   define SWIGUNUSED __attribute__ ((__unused__))
75 # else
76 #   define SWIGUNUSED
77 # endif
78 #endif
79
80 #ifndef SWIG_MSC_UNSUPPRESS_4505
81 # if defined(_MSC_VER)
82 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
83 # endif
84 #endif
85
86 #ifndef SWIGUNUSEDPARM
87 # ifdef __cplusplus
88 #   define SWIGUNUSEDPARM(p)
89 # else
90 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
91 # endif
92 #endif
93
94 /* internal SWIG method */
95 #ifndef SWIGINTERN
96 # define SWIGINTERN static SWIGUNUSED
97 #endif
98
99 /* internal inline SWIG method */
100 #ifndef SWIGINTERNINLINE
101 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
102 #endif
103
104 /* exporting methods */
105 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
106 #  ifndef GCC_HASCLASSVISIBILITY
107 #    define GCC_HASCLASSVISIBILITY
108 #  endif
109 #endif
110
111 #ifndef SWIGEXPORT
112 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
113 #   if defined(STATIC_LINKED)
114 #     define SWIGEXPORT
115 #   else
116 #     define SWIGEXPORT __declspec(dllexport)
117 #   endif
118 # else
119 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
120 #     define SWIGEXPORT __attribute__ ((visibility("default")))
121 #   else
122 #     define SWIGEXPORT
123 #   endif
124 # endif
125 #endif
126
127 /* calling conventions for Windows */
128 #ifndef SWIGSTDCALL
129 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
130 #   define SWIGSTDCALL __stdcall
131 # else
132 #   define SWIGSTDCALL
133 # endif
134 #endif
135
136 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
137 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
138 # define _CRT_SECURE_NO_DEPRECATE
139 #endif
140
141 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
142 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
143 # define _SCL_SECURE_NO_DEPRECATE
144 #endif
145
146 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
147 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
148 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
149 #endif
150
151 /* Intel's compiler complains if a variable which was never initialised is
152  * cast to void, which is a common idiom which we use to indicate that we
153  * are aware a variable isn't used.  So we just silence that warning.
154  * See: https://github.com/swig/swig/issues/192 for more discussion.
155  */
156 #ifdef __INTEL_COMPILER
157 # pragma warning disable 592
158 #endif
159
160
161 /* Fix for jlong on some versions of gcc on Windows */
162 #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
163   typedef long long __int64;
164 #endif
165
166 /* Fix for jlong on 64-bit x86 Solaris */
167 #if defined(__x86_64)
168 # ifdef _LP64
169 #   undef _LP64
170 # endif
171 #endif
172
173 #include <jni.h>
174 #include <stdlib.h>
175 #include <string.h>
176
177
178 /* Support for throwing Java exceptions */
179 typedef enum {
180   SWIG_JavaOutOfMemoryError = 1, 
181   SWIG_JavaIOException, 
182   SWIG_JavaRuntimeException, 
183   SWIG_JavaIndexOutOfBoundsException,
184   SWIG_JavaArithmeticException,
185   SWIG_JavaIllegalArgumentException,
186   SWIG_JavaNullPointerException,
187   SWIG_JavaDirectorPureVirtual,
188   SWIG_JavaUnknownError
189 } SWIG_JavaExceptionCodes;
190
191 typedef struct {
192   SWIG_JavaExceptionCodes code;
193   const char *java_exception;
194 } SWIG_JavaExceptions_t;
195
196
197 static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) {
198   jclass excep;
199   static const SWIG_JavaExceptions_t java_exceptions[] = {
200     { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" },
201     { SWIG_JavaIOException, "java/io/IOException" },
202     { SWIG_JavaRuntimeException, "java/lang/RuntimeException" },
203     { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" },
204     { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" },
205     { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" },
206     { SWIG_JavaNullPointerException, "java/lang/NullPointerException" },
207     { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" },
208     { SWIG_JavaUnknownError,  "java/lang/UnknownError" },
209     { (SWIG_JavaExceptionCodes)0,  "java/lang/UnknownError" }
210   };
211   const SWIG_JavaExceptions_t *except_ptr = java_exceptions;
212
213   while (except_ptr->code != code && except_ptr->code)
214     except_ptr++;
215
216   jenv->ExceptionClear();
217   excep = jenv->FindClass(except_ptr->java_exception);
218   if (excep)
219     jenv->ThrowNew(excep, msg);
220 }
221
222
223 /* Contract support */
224
225 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } else
226
227 /* -----------------------------------------------------------------------------
228  * director_common.swg
229  *
230  * This file contains support for director classes which is common between
231  * languages.
232  * ----------------------------------------------------------------------------- */
233
234 /*
235   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
236   'Swig' namespace. This could be useful for multi-modules projects.
237 */
238 #ifdef SWIG_DIRECTOR_STATIC
239 /* Force anonymous (static) namespace */
240 #define Swig
241 #endif
242 /* -----------------------------------------------------------------------------
243  * director.swg
244  *
245  * This file contains support for director classes so that Java proxy
246  * methods can be called from C++.
247  * ----------------------------------------------------------------------------- */
248
249 #if defined(DEBUG_DIRECTOR_OWNED) || defined(DEBUG_DIRECTOR_EXCEPTION)
250 #include <iostream>
251 #endif
252
253 #include <exception>
254
255 namespace Swig {
256
257   /* Java object wrapper */
258   class JObjectWrapper {
259   public:
260     JObjectWrapper() : jthis_(NULL), weak_global_(true) {
261     }
262
263     ~JObjectWrapper() {
264       jthis_ = NULL;
265       weak_global_ = true;
266     }
267
268     bool set(JNIEnv *jenv, jobject jobj, bool mem_own, bool weak_global) {
269       if (!jthis_) {
270         weak_global_ = weak_global || !mem_own; // hold as weak global if explicitly requested or not owned
271         if (jobj)
272           jthis_ = weak_global_ ? jenv->NewWeakGlobalRef(jobj) : jenv->NewGlobalRef(jobj);
273 #if defined(DEBUG_DIRECTOR_OWNED)
274         std::cout << "JObjectWrapper::set(" << jobj << ", " << (weak_global ? "weak_global" : "global_ref") << ") -> " << jthis_ << std::endl;
275 #endif
276         return true;
277       } else {
278 #if defined(DEBUG_DIRECTOR_OWNED)
279         std::cout << "JObjectWrapper::set(" << jobj << ", " << (weak_global ? "weak_global" : "global_ref") << ") -> already set" << std::endl;
280 #endif
281         return false;
282       }
283     }
284
285     jobject get(JNIEnv *jenv) const {
286 #if defined(DEBUG_DIRECTOR_OWNED)
287       std::cout << "JObjectWrapper::get(";
288       if (jthis_)
289         std::cout << jthis_;
290       else
291         std::cout << "null";
292       std::cout << ") -> return new local ref" << std::endl;
293 #endif
294       return (jthis_ ? jenv->NewLocalRef(jthis_) : jthis_);
295     }
296
297     void release(JNIEnv *jenv) {
298 #if defined(DEBUG_DIRECTOR_OWNED)
299       std::cout << "JObjectWrapper::release(" << jthis_ << "): " << (weak_global_ ? "weak global ref" : "global ref") << std::endl;
300 #endif
301       if (jthis_) {
302         if (weak_global_) {
303           if (jenv->IsSameObject(jthis_, NULL) == JNI_FALSE)
304             jenv->DeleteWeakGlobalRef((jweak)jthis_);
305         } else
306           jenv->DeleteGlobalRef(jthis_);
307       }
308
309       jthis_ = NULL;
310       weak_global_ = true;
311     }
312
313     /* Only call peek if you know what you are doing wrt to weak/global references */
314     jobject peek() {
315       return jthis_;
316     }
317
318     /* Java proxy releases ownership of C++ object, C++ object is now
319        responsible for destruction (creates NewGlobalRef to pin Java proxy) */
320     void java_change_ownership(JNIEnv *jenv, jobject jself, bool take_or_release) {
321       if (take_or_release) {  /* Java takes ownership of C++ object's lifetime. */
322         if (!weak_global_) {
323           jenv->DeleteGlobalRef(jthis_);
324           jthis_ = jenv->NewWeakGlobalRef(jself);
325           weak_global_ = true;
326         }
327       } else {
328         /* Java releases ownership of C++ object's lifetime */
329         if (weak_global_) {
330           jenv->DeleteWeakGlobalRef((jweak)jthis_);
331           jthis_ = jenv->NewGlobalRef(jself);
332           weak_global_ = false;
333         }
334       }
335     }
336
337   private:
338     /* pointer to Java object */
339     jobject jthis_;
340     /* Local or global reference flag */
341     bool weak_global_;
342   };
343
344   /* Local JNI reference deleter */
345   class LocalRefGuard {
346     JNIEnv *jenv_;
347     jobject jobj_;
348
349     // non-copyable
350     LocalRefGuard(const LocalRefGuard &);
351     LocalRefGuard &operator=(const LocalRefGuard &);
352   public:
353     LocalRefGuard(JNIEnv *jenv, jobject jobj): jenv_(jenv), jobj_(jobj) {}
354     ~LocalRefGuard() {
355       if (jobj_)
356         jenv_->DeleteLocalRef(jobj_);
357     }
358   };
359
360   /* director base class */
361   class Director {
362     /* pointer to Java virtual machine */
363     JavaVM *swig_jvm_;
364
365   protected:
366 #if defined (_MSC_VER) && (_MSC_VER<1300)
367     class JNIEnvWrapper;
368     friend class JNIEnvWrapper;
369 #endif
370     /* Utility class for managing the JNI environment */
371     class JNIEnvWrapper {
372       const Director *director_;
373       JNIEnv *jenv_;
374       int env_status;
375     public:
376       JNIEnvWrapper(const Director *director) : director_(director), jenv_(0), env_status(0) {
377 #if defined(__ANDROID__)
378         JNIEnv **jenv = &jenv_;
379 #else
380         void **jenv = (void **)&jenv_;
381 #endif
382         env_status = director_->swig_jvm_->GetEnv((void **)&jenv_, JNI_VERSION_1_2);
383 #if defined(SWIG_JAVA_ATTACH_CURRENT_THREAD_AS_DAEMON)
384         // Attach a daemon thread to the JVM. Useful when the JVM should not wait for
385         // the thread to exit upon shutdown. Only for jdk-1.4 and later.
386         director_->swig_jvm_->AttachCurrentThreadAsDaemon(jenv, NULL);
387 #else
388         director_->swig_jvm_->AttachCurrentThread(jenv, NULL);
389 #endif
390       }
391       ~JNIEnvWrapper() {
392 #if !defined(SWIG_JAVA_NO_DETACH_CURRENT_THREAD)
393         // Some JVMs, eg jdk-1.4.2 and lower on Solaris have a bug and crash with the DetachCurrentThread call.
394         // However, without this call, the JVM hangs on exit when the thread was not created by the JVM and creates a memory leak.
395         if (env_status == JNI_EDETACHED)
396           director_->swig_jvm_->DetachCurrentThread();
397 #endif
398       }
399       JNIEnv *getJNIEnv() const {
400         return jenv_;
401       }
402     };
403
404     /* Java object wrapper */
405     JObjectWrapper swig_self_;
406
407     /* Disconnect director from Java object */
408     void swig_disconnect_director_self(const char *disconn_method) {
409       JNIEnvWrapper jnienv(this) ;
410       JNIEnv *jenv = jnienv.getJNIEnv() ;
411       jobject jobj = swig_self_.get(jenv);
412       LocalRefGuard ref_deleter(jenv, jobj);
413 #if defined(DEBUG_DIRECTOR_OWNED)
414       std::cout << "Swig::Director::disconnect_director_self(" << jobj << ")" << std::endl;
415 #endif
416       if (jobj && jenv->IsSameObject(jobj, NULL) == JNI_FALSE) {
417         jmethodID disconn_meth = jenv->GetMethodID(jenv->GetObjectClass(jobj), disconn_method, "()V");
418         if (disconn_meth) {
419 #if defined(DEBUG_DIRECTOR_OWNED)
420           std::cout << "Swig::Director::disconnect_director_self upcall to " << disconn_method << std::endl;
421 #endif
422           jenv->CallVoidMethod(jobj, disconn_meth);
423         }
424       }
425     }
426
427   public:
428     Director(JNIEnv *jenv) : swig_jvm_((JavaVM *) NULL), swig_self_() {
429       /* Acquire the Java VM pointer */
430       jenv->GetJavaVM(&swig_jvm_);
431     }
432
433     virtual ~Director() {
434       JNIEnvWrapper jnienv(this) ;
435       JNIEnv *jenv = jnienv.getJNIEnv() ;
436       swig_self_.release(jenv);
437     }
438
439     bool swig_set_self(JNIEnv *jenv, jobject jself, bool mem_own, bool weak_global) {
440       return swig_self_.set(jenv, jself, mem_own, weak_global);
441     }
442
443     jobject swig_get_self(JNIEnv *jenv) const {
444       return swig_self_.get(jenv);
445     }
446
447     // Change C++ object's ownership, relative to Java
448     void swig_java_change_ownership(JNIEnv *jenv, jobject jself, bool take_or_release) {
449       swig_self_.java_change_ownership(jenv, jself, take_or_release);
450     }
451   };
452
453   // Zero initialized bool array
454   template<size_t N> class BoolArray {
455     bool array_[N];
456   public:
457     BoolArray() {
458       memset(array_, 0, sizeof(array_));
459     }
460     bool& operator[](size_t n) {
461       return array_[n];
462     }
463     bool operator[](size_t n) const {
464       return array_[n];
465     }
466   };
467
468   // Utility classes and functions for exception handling.
469
470   // Simple holder for a Java string during exception handling, providing access to a c-style string
471   class JavaString {
472   public:
473     JavaString(JNIEnv *jenv, jstring jstr) : jenv_(jenv), jstr_(jstr), cstr_(0) {
474       if (jenv_ && jstr_)
475         cstr_ = (const char *) jenv_->GetStringUTFChars(jstr_, NULL);
476     }
477
478     ~JavaString() {
479       if (jenv_ && jstr_ && cstr_)
480         jenv_->ReleaseStringUTFChars(jstr_, cstr_);
481     }
482
483     const char *c_str(const char *null_string = "null JavaString") const {
484       return cstr_ ? cstr_ : null_string;
485     }
486
487   private:
488     // non-copyable
489     JavaString(const JavaString &);
490     JavaString &operator=(const JavaString &);
491
492     JNIEnv *jenv_;
493     jstring jstr_;
494     const char *cstr_;
495   };
496
497   // Helper class to extract the exception message from a Java throwable
498   class JavaExceptionMessage {
499   public:
500     JavaExceptionMessage(JNIEnv *jenv, jthrowable throwable) : message_(jenv, exceptionMessageFromThrowable(jenv, throwable)) {
501     }
502
503     const char *message() const {
504       return message_.c_str("Could not get exception message in JavaExceptionMessage");
505     }
506
507   private:
508     // non-copyable
509     JavaExceptionMessage(const JavaExceptionMessage &);
510     JavaExceptionMessage &operator=(const JavaExceptionMessage &);
511
512     // Get exception message by calling Java method Throwable.getMessage()
513     static jstring exceptionMessageFromThrowable(JNIEnv *jenv, jthrowable throwable) {
514       jstring jmsg = NULL;
515       if (jenv && throwable) {
516         jenv->ExceptionClear(); // Cannot invoke methods with any pending exceptions
517         jclass throwclz = jenv->GetObjectClass(throwable);
518         if (throwclz) {
519           // All Throwable classes have a getMessage() method, so call it to extract the exception message
520           jmethodID getMessageMethodID = jenv->GetMethodID(throwclz, "getMessage", "()Ljava/lang/String;");
521           if (getMessageMethodID)
522             jmsg = (jstring)jenv->CallObjectMethod(throwable, getMessageMethodID);
523         }
524         if (jmsg == NULL && jenv->ExceptionCheck())
525           jenv->ExceptionClear();
526       }
527       return jmsg;
528     }
529
530     JavaString message_;
531   };
532
533   // C++ Exception class for handling Java exceptions thrown during a director method Java upcall
534   class DirectorException : public std::exception {
535   public:
536
537     // Construct exception from a Java throwable
538     DirectorException(JNIEnv *jenv, jthrowable throwable) : classname_(0), msg_(0) {
539
540       // Call Java method Object.getClass().getName() to obtain the throwable's class name (delimited by '/')
541       if (throwable) {
542         jclass throwclz = jenv->GetObjectClass(throwable);
543         if (throwclz) {
544           jclass clzclz = jenv->GetObjectClass(throwclz);
545           if (clzclz) {
546             jmethodID getNameMethodID = jenv->GetMethodID(clzclz, "getName", "()Ljava/lang/String;");
547             if (getNameMethodID) {
548               jstring jstr_classname = (jstring)(jenv->CallObjectMethod(throwclz, getNameMethodID));
549               // Copy strings, since there is no guarantee that jenv will be active when handled
550               if (jstr_classname) {
551                 JavaString jsclassname(jenv, jstr_classname);
552                 const char *classname = jsclassname.c_str(0);
553                 if (classname)
554                   classname_ = copypath(classname);
555               }
556             }
557           }
558         }
559       }
560
561       JavaExceptionMessage exceptionmsg(jenv, throwable);
562       msg_ = copystr(exceptionmsg.message());
563     }
564
565     // More general constructor for handling as a java.lang.RuntimeException
566     DirectorException(const char *msg) : classname_(0), msg_(copystr(msg ? msg : "Unspecified DirectorException message")) {
567     }
568
569     ~DirectorException() throw() {
570       delete[] classname_;
571       delete[] msg_;
572     }
573
574     const char *what() const throw() {
575       return msg_;
576     }
577
578     // Reconstruct and raise/throw the Java Exception that caused the DirectorException
579     // Note that any error in the JNI exception handling results in a Java RuntimeException
580     void raiseJavaException(JNIEnv *jenv) const {
581       if (jenv) {
582         jenv->ExceptionClear();
583
584         jmethodID ctorMethodID = 0;
585         jclass throwableclass = 0;
586         if (classname_) {
587           throwableclass = jenv->FindClass(classname_);
588           if (throwableclass)
589             ctorMethodID = jenv->GetMethodID(throwableclass, "<init>", "(Ljava/lang/String;)V");
590         }
591
592         if (ctorMethodID) {
593           jenv->ThrowNew(throwableclass, what());
594         } else {
595           SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, what());
596         }
597       }
598     }
599
600   private:
601     static char *copypath(const char *srcmsg) {
602       char *target = copystr(srcmsg);
603       for (char *c=target; *c; ++c) {
604         if ('.' == *c)
605           *c = '/';
606       }
607       return target;
608     }
609
610     static char *copystr(const char *srcmsg) {
611       char *target = 0;
612       if (srcmsg) {
613         size_t msglen = strlen(srcmsg) + 1;
614         target = new char[msglen];
615         strncpy(target, srcmsg, msglen);
616       }
617       return target;
618     }
619
620     const char *classname_;
621     const char *msg_;
622   };
623
624   // Helper method to determine if a Java throwable matches a particular Java class type
625   SWIGINTERN bool ExceptionMatches(JNIEnv *jenv, jthrowable throwable, const char *classname) {
626     bool matches = false;
627
628     if (throwable && jenv && classname) {
629       // Exceptions need to be cleared for correct behavior.
630       // The caller of ExceptionMatches should restore pending exceptions if desired -
631       // the caller already has the throwable.
632       jenv->ExceptionClear();
633
634       jclass clz = jenv->FindClass(classname);
635       if (clz) {
636         jclass classclz = jenv->GetObjectClass(clz);
637         jmethodID isInstanceMethodID = jenv->GetMethodID(classclz, "isInstance", "(Ljava/lang/Object;)Z");
638         if (isInstanceMethodID) {
639           matches = jenv->CallBooleanMethod(clz, isInstanceMethodID, throwable) != 0;
640         }
641       }
642
643 #if defined(DEBUG_DIRECTOR_EXCEPTION)
644       if (jenv->ExceptionCheck()) {
645         // Typically occurs when an invalid classname argument is passed resulting in a ClassNotFoundException
646         JavaExceptionMessage exc(jenv, jenv->ExceptionOccurred());
647         std::cout << "Error: ExceptionMatches: class '" << classname << "' : " << exc.message() << std::endl;
648       }
649 #endif
650     }
651     return matches;
652   }
653 }
654
655 namespace Swig {
656   namespace {
657     jclass jclass_JavaControllerJNI = NULL;
658     jmethodID director_method_ids[5];
659   }
660 }
661
662 #include <vector>
663 #include <string>
664
665 #include "utilities.hxx"
666 #include "View.hxx"
667 #include "Controller.hxx"
668
669
670 #include <stdexcept>
671
672
673 #include <vector>
674 #include <stdexcept>
675
676
677 #include <string>
678
679 SWIGINTERN std::vector< double >::const_reference std_vector_Sl_double_Sg__get(std::vector< double > *self,int i){
680                 int size = int(self->size());
681                 if (i>=0 && i<size)
682                     return (*self)[i];
683                 else
684                     throw std::out_of_range("vector index out of range");
685             }
686 SWIGINTERN void std_vector_Sl_double_Sg__set(std::vector< double > *self,int i,std::vector< double >::value_type const &val){
687                 int size = int(self->size());
688                 if (i>=0 && i<size)
689                     (*self)[i] = val;
690                 else
691                     throw std::out_of_range("vector index out of range");
692             }
693 SWIGINTERN std::vector< int >::const_reference std_vector_Sl_int_Sg__get(std::vector< int > *self,int i){
694                 int size = int(self->size());
695                 if (i>=0 && i<size)
696                     return (*self)[i];
697                 else
698                     throw std::out_of_range("vector index out of range");
699             }
700 SWIGINTERN void std_vector_Sl_int_Sg__set(std::vector< int > *self,int i,std::vector< int >::value_type const &val){
701                 int size = int(self->size());
702                 if (i>=0 && i<size)
703                     (*self)[i] = val;
704                 else
705                     throw std::out_of_range("vector index out of range");
706             }
707 SWIGINTERN bool std_vector_Sl_bool_Sg__get(std::vector< bool > *self,int i){
708                 int size = int(self->size());
709                 if (i>=0 && i<size)
710                     return (*self)[i];
711                 else
712                     throw std::out_of_range("vector index out of range");
713             }
714 SWIGINTERN void std_vector_Sl_bool_Sg__set(std::vector< bool > *self,int i,std::vector< bool >::value_type const &val){
715                 int size = int(self->size());
716                 if (i>=0 && i<size)
717                     (*self)[i] = val;
718                 else
719                     throw std::out_of_range("vector index out of range");
720             }
721 SWIGINTERN std::vector< std::string >::const_reference std_vector_Sl_std_string_Sg__get(std::vector< std::string > *self,int i){
722                 int size = int(self->size());
723                 if (i>=0 && i<size)
724                     return (*self)[i];
725                 else
726                     throw std::out_of_range("vector index out of range");
727             }
728 SWIGINTERN void std_vector_Sl_std_string_Sg__set(std::vector< std::string > *self,int i,std::vector< std::string >::value_type const &val){
729                 int size = int(self->size());
730                 if (i>=0 && i<size)
731                     (*self)[i] = val;
732                 else
733                     throw std::out_of_range("vector index out of range");
734             }
735 SWIGINTERN std::vector< long long >::const_reference std_vector_Sl_ScicosID_Sg__get(std::vector< ScicosID > *self,int i){
736                 int size = int(self->size());
737                 if (i>=0 && i<size)
738                     return (*self)[i];
739                 else
740                     throw std::out_of_range("vector index out of range");
741             }
742 SWIGINTERN void std_vector_Sl_ScicosID_Sg__set(std::vector< ScicosID > *self,int i,std::vector< long long >::value_type const &val){
743                 int size = int(self->size());
744                 if (i>=0 && i<size)
745                     (*self)[i] = val;
746                 else
747                     throw std::out_of_range("vector index out of range");
748             }
749
750 static void register_view(const std::string& name, org_scilab_modules_scicos::View* view) {
751   org_scilab_modules_scicos::Controller::register_view(name, view);
752 };
753 static void unregister_view(org_scilab_modules_scicos::View* view) {
754   org_scilab_modules_scicos::Controller::unregister_view(view);
755 };
756
757
758
759 /* ---------------------------------------------------
760  * C++ director class methods
761  * --------------------------------------------------- */
762
763 #include "JavaController_wrap.h"
764
765 SwigDirector_View::SwigDirector_View(JNIEnv *jenv) : org_scilab_modules_scicos::View(), Swig::Director(jenv) {
766 }
767
768 SwigDirector_View::~SwigDirector_View() {
769   swig_disconnect_director_self("swigDirectorDisconnect");
770 }
771
772
773 void SwigDirector_View::objectCreated(ScicosID const &uid, kind_t kind) {
774   JNIEnvWrapper swigjnienv(this) ;
775   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
776   jobject swigjobj = (jobject) NULL ;
777   jlong juid = 0 ;
778   jint jkind  ;
779   
780   if (!swig_override[0]) {
781     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectCreated.");
782     return;
783   }
784   swigjobj = swig_get_self(jenv);
785   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
786     juid = (jlong)uid;
787     jkind = (jint) kind;
788     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[0], swigjobj, juid, jkind);
789     jthrowable swigerror = jenv->ExceptionOccurred();
790     if (swigerror) {
791       jenv->ExceptionClear();
792       throw Swig::DirectorException(jenv, swigerror);
793     }
794     
795   } else {
796     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectCreated ");
797   }
798   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
799 }
800
801 void SwigDirector_View::objectReferenced(ScicosID const &uid, kind_t kind) {
802   JNIEnvWrapper swigjnienv(this) ;
803   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
804   jobject swigjobj = (jobject) NULL ;
805   jlong juid = 0 ;
806   jint jkind  ;
807   
808   if (!swig_override[1]) {
809     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectReferenced.");
810     return;
811   }
812   swigjobj = swig_get_self(jenv);
813   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
814     juid = (jlong)uid;
815     jkind = (jint) kind;
816     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[1], swigjobj, juid, jkind);
817     jthrowable swigerror = jenv->ExceptionOccurred();
818     if (swigerror) {
819       jenv->ExceptionClear();
820       throw Swig::DirectorException(jenv, swigerror);
821     }
822     
823   } else {
824     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectReferenced ");
825   }
826   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
827 }
828
829 void SwigDirector_View::objectUnreferenced(ScicosID const &uid, kind_t kind) {
830   JNIEnvWrapper swigjnienv(this) ;
831   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
832   jobject swigjobj = (jobject) NULL ;
833   jlong juid = 0 ;
834   jint jkind  ;
835   
836   if (!swig_override[2]) {
837     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectUnreferenced.");
838     return;
839   }
840   swigjobj = swig_get_self(jenv);
841   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
842     juid = (jlong)uid;
843     jkind = (jint) kind;
844     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[2], swigjobj, juid, jkind);
845     jthrowable swigerror = jenv->ExceptionOccurred();
846     if (swigerror) {
847       jenv->ExceptionClear();
848       throw Swig::DirectorException(jenv, swigerror);
849     }
850     
851   } else {
852     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectUnreferenced ");
853   }
854   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
855 }
856
857 void SwigDirector_View::objectDeleted(ScicosID const &uid, kind_t kind) {
858   JNIEnvWrapper swigjnienv(this) ;
859   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
860   jobject swigjobj = (jobject) NULL ;
861   jlong juid = 0 ;
862   jint jkind  ;
863   
864   if (!swig_override[3]) {
865     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectDeleted.");
866     return;
867   }
868   swigjobj = swig_get_self(jenv);
869   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
870     juid = (jlong)uid;
871     jkind = (jint) kind;
872     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[3], swigjobj, juid, jkind);
873     jthrowable swigerror = jenv->ExceptionOccurred();
874     if (swigerror) {
875       jenv->ExceptionClear();
876       throw Swig::DirectorException(jenv, swigerror);
877     }
878     
879   } else {
880     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectDeleted ");
881   }
882   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
883 }
884
885 void SwigDirector_View::propertyUpdated(ScicosID const &uid, kind_t kind, object_properties_t property, update_status_t status) {
886   JNIEnvWrapper swigjnienv(this) ;
887   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
888   jobject swigjobj = (jobject) NULL ;
889   jlong juid = 0 ;
890   jint jkind  ;
891   jint jproperty  ;
892   jint jstatus  ;
893   
894   if (!swig_override[4]) {
895     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::propertyUpdated.");
896     return;
897   }
898   swigjobj = swig_get_self(jenv);
899   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
900     juid = (jlong)uid;
901     jkind = (jint) kind;
902     jproperty = (jint) property;
903     jstatus = (jint) status;
904     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[4], swigjobj, juid, jkind, jproperty, jstatus);
905     jthrowable swigerror = jenv->ExceptionOccurred();
906     if (swigerror) {
907       jenv->ExceptionClear();
908       throw Swig::DirectorException(jenv, swigerror);
909     }
910     
911   } else {
912     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::propertyUpdated ");
913   }
914   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
915 }
916
917 void SwigDirector_View::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {
918   static struct {
919     const char *mname;
920     const char *mdesc;
921     jmethodID base_methid;
922   } methods[] = {
923     {
924       "objectCreated", "(JLorg/scilab/modules/xcos/Kind;)V", NULL 
925     },
926     {
927       "objectReferenced", "(JLorg/scilab/modules/xcos/Kind;)V", NULL 
928     },
929     {
930       "objectUnreferenced", "(JLorg/scilab/modules/xcos/Kind;)V", NULL 
931     },
932     {
933       "objectDeleted", "(JLorg/scilab/modules/xcos/Kind;)V", NULL 
934     },
935     {
936       "propertyUpdated", "(JLorg/scilab/modules/xcos/Kind;Lorg/scilab/modules/xcos/ObjectProperties;Lorg/scilab/modules/xcos/UpdateStatus;)V", NULL 
937     }
938   };
939   
940   static jclass baseclass = 0 ;
941   
942   if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
943     if (!baseclass) {
944       baseclass = jenv->FindClass("org/scilab/modules/xcos/View");
945       if (!baseclass) return;
946       baseclass = (jclass) jenv->NewGlobalRef(baseclass);
947     }
948     bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
949     for (int i = 0; i < 5; ++i) {
950       if (!methods[i].base_methid) {
951         methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);
952         if (!methods[i].base_methid) return;
953       }
954       swig_override[i] = false;
955       if (derived) {
956         jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);
957         swig_override[i] = (methid != methods[i].base_methid);
958         jenv->ExceptionClear();
959       }
960     }
961   }
962 }
963
964
965
966 #ifdef __cplusplus
967 extern "C" {
968 #endif
969
970 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1View(JNIEnv *jenv, jclass jcls) {
971   jlong jresult = 0 ;
972   org_scilab_modules_scicos::View *result = 0 ;
973   
974   (void)jenv;
975   (void)jcls;
976   result = (org_scilab_modules_scicos::View *)new SwigDirector_View(jenv);
977   *(org_scilab_modules_scicos::View **)&jresult = result; 
978   return jresult;
979 }
980
981
982 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1View(JNIEnv *jenv, jclass jcls, jlong jarg1) {
983   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
984   
985   (void)jenv;
986   (void)jcls;
987   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
988   delete arg1;
989 }
990
991
992 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectCreated(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) {
993   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
994   ScicosID *arg2 = 0 ;
995   kind_t arg3 ;
996   ScicosID temp2 ;
997   
998   (void)jenv;
999   (void)jcls;
1000   (void)jarg1_;
1001   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1002   temp2 = (ScicosID)jarg2; 
1003   arg2 = &temp2; 
1004   arg3 = (kind_t)jarg3; 
1005   (arg1)->objectCreated((ScicosID const &)*arg2,arg3);
1006 }
1007
1008
1009 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectReferenced(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) {
1010   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1011   ScicosID *arg2 = 0 ;
1012   kind_t arg3 ;
1013   ScicosID temp2 ;
1014   
1015   (void)jenv;
1016   (void)jcls;
1017   (void)jarg1_;
1018   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1019   temp2 = (ScicosID)jarg2; 
1020   arg2 = &temp2; 
1021   arg3 = (kind_t)jarg3; 
1022   (arg1)->objectReferenced((ScicosID const &)*arg2,arg3);
1023 }
1024
1025
1026 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectUnreferenced(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) {
1027   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1028   ScicosID *arg2 = 0 ;
1029   kind_t arg3 ;
1030   ScicosID temp2 ;
1031   
1032   (void)jenv;
1033   (void)jcls;
1034   (void)jarg1_;
1035   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1036   temp2 = (ScicosID)jarg2; 
1037   arg2 = &temp2; 
1038   arg3 = (kind_t)jarg3; 
1039   (arg1)->objectUnreferenced((ScicosID const &)*arg2,arg3);
1040 }
1041
1042
1043 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectDeleted(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) {
1044   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1045   ScicosID *arg2 = 0 ;
1046   kind_t arg3 ;
1047   ScicosID temp2 ;
1048   
1049   (void)jenv;
1050   (void)jcls;
1051   (void)jarg1_;
1052   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1053   temp2 = (ScicosID)jarg2; 
1054   arg2 = &temp2; 
1055   arg3 = (kind_t)jarg3; 
1056   (arg1)->objectDeleted((ScicosID const &)*arg2,arg3);
1057 }
1058
1059
1060 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1propertyUpdated(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jint jarg5) {
1061   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1062   ScicosID *arg2 = 0 ;
1063   kind_t arg3 ;
1064   object_properties_t arg4 ;
1065   update_status_t arg5 ;
1066   ScicosID temp2 ;
1067   
1068   (void)jenv;
1069   (void)jcls;
1070   (void)jarg1_;
1071   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1072   temp2 = (ScicosID)jarg2; 
1073   arg2 = &temp2; 
1074   arg3 = (kind_t)jarg3; 
1075   arg4 = (object_properties_t)jarg4; 
1076   arg5 = (update_status_t)jarg5; 
1077   (arg1)->propertyUpdated((ScicosID const &)*arg2,arg3,arg4,arg5);
1078 }
1079
1080
1081 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) {
1082   org_scilab_modules_scicos::View *obj = *((org_scilab_modules_scicos::View **)&objarg);
1083   (void)jcls;
1084   SwigDirector_View *director = dynamic_cast<SwigDirector_View *>(obj);
1085   if (director) {
1086     director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));
1087   }
1088 }
1089
1090
1091 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {
1092   org_scilab_modules_scicos::View *obj = *((org_scilab_modules_scicos::View **)&objarg);
1093   SwigDirector_View *director = dynamic_cast<SwigDirector_View *>(obj);
1094   (void)jcls;
1095   if (director) {
1096     director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);
1097   }
1098 }
1099
1100
1101 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1look_1for_1view(JNIEnv *jenv, jclass jcls, jstring jarg1) {
1102   jlong jresult = 0 ;
1103   std::string *arg1 = 0 ;
1104   org_scilab_modules_scicos::View *result = 0 ;
1105   
1106   (void)jenv;
1107   (void)jcls;
1108   if(!jarg1) {
1109     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
1110     return 0;
1111   }
1112   const char *arg1_pstr = (const char *)jenv->GetStringUTFChars(jarg1, 0); 
1113   if (!arg1_pstr) return 0;
1114   std::string arg1_str(arg1_pstr);
1115   arg1 = &arg1_str;
1116   jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
1117   result = (org_scilab_modules_scicos::View *)org_scilab_modules_scicos::Controller::look_for_view((std::string const &)*arg1);
1118   *(org_scilab_modules_scicos::View **)&jresult = result; 
1119   return jresult;
1120 }
1121
1122
1123 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1Controller(JNIEnv *jenv, jclass jcls) {
1124   jlong jresult = 0 ;
1125   org_scilab_modules_scicos::Controller *result = 0 ;
1126   
1127   (void)jenv;
1128   (void)jcls;
1129   result = (org_scilab_modules_scicos::Controller *)new org_scilab_modules_scicos::Controller();
1130   *(org_scilab_modules_scicos::Controller **)&jresult = result; 
1131   return jresult;
1132 }
1133
1134
1135 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1Controller(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1136   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1137   
1138   (void)jenv;
1139   (void)jcls;
1140   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1141   delete arg1;
1142 }
1143
1144
1145 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1createObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
1146   jlong jresult = 0 ;
1147   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1148   kind_t arg2 ;
1149   ScicosID result;
1150   
1151   (void)jenv;
1152   (void)jcls;
1153   (void)jarg1_;
1154   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1155   arg2 = (kind_t)jarg2; 
1156   result = (ScicosID)(arg1)->createObject(arg2);
1157   jresult = (jlong)result; 
1158   return jresult;
1159 }
1160
1161
1162 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1referenceObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1163   jlong jresult = 0 ;
1164   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1165   ScicosID arg2 ;
1166   unsigned int result;
1167   
1168   (void)jenv;
1169   (void)jcls;
1170   (void)jarg1_;
1171   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1172   arg2 = (ScicosID)jarg2; 
1173   result = (unsigned int)((org_scilab_modules_scicos::Controller const *)arg1)->referenceObject(arg2);
1174   jresult = (jlong)result; 
1175   return jresult;
1176 }
1177
1178
1179 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1deleteObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1180   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1181   ScicosID arg2 ;
1182   
1183   (void)jenv;
1184   (void)jcls;
1185   (void)jarg1_;
1186   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1187   arg2 = (ScicosID)jarg2; 
1188   (arg1)->deleteObject(arg2);
1189 }
1190
1191
1192 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1cloneObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jboolean jarg3) {
1193   jlong jresult = 0 ;
1194   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1195   ScicosID arg2 ;
1196   bool arg3 ;
1197   ScicosID result;
1198   
1199   (void)jenv;
1200   (void)jcls;
1201   (void)jarg1_;
1202   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1203   arg2 = (ScicosID)jarg2; 
1204   arg3 = jarg3 ? true : false; 
1205   result = (ScicosID)(arg1)->cloneObject(arg2,arg3);
1206   jresult = (jlong)result; 
1207   return jresult;
1208 }
1209
1210
1211 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getKind(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1212   jint jresult = 0 ;
1213   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1214   ScicosID arg2 ;
1215   kind_t result;
1216   
1217   (void)jenv;
1218   (void)jcls;
1219   (void)jarg1_;
1220   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1221   arg2 = (ScicosID)jarg2; 
1222   result = (kind_t)((org_scilab_modules_scicos::Controller const *)arg1)->getKind(arg2);
1223   jresult = (jint)result; 
1224   return jresult;
1225 }
1226
1227
1228 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getAll(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
1229   jlong jresult = 0 ;
1230   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1231   kind_t arg2 ;
1232   std::vector< ScicosID > result;
1233   
1234   (void)jenv;
1235   (void)jcls;
1236   (void)jarg1_;
1237   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1238   arg2 = (kind_t)jarg2; 
1239   result = ((org_scilab_modules_scicos::Controller const *)arg1)->getAll(arg2);
1240   *(std::vector< ScicosID > **)&jresult = new std::vector< ScicosID >((const std::vector< ScicosID > &)result); 
1241   return jresult;
1242 }
1243
1244
1245 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jintArray jarg5) {
1246   jboolean jresult = 0 ;
1247   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1248   ScicosID arg2 ;
1249   kind_t arg3 ;
1250   object_properties_t arg4 ;
1251   int *arg5 = 0 ;
1252   int temp5 ;
1253   bool result;
1254   
1255   (void)jenv;
1256   (void)jcls;
1257   (void)jarg1_;
1258   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1259   arg2 = (ScicosID)jarg2; 
1260   arg3 = (kind_t)jarg3; 
1261   arg4 = (object_properties_t)jarg4; 
1262   {
1263     if (!jarg5) {
1264       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1265       return 0;
1266     }
1267     if (jenv->GetArrayLength(jarg5) == 0) {
1268       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1269       return 0;
1270     }
1271     temp5 = (int)0;
1272     arg5 = &temp5; 
1273   }
1274   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< int >(arg2,arg3,arg4,*arg5);
1275   jresult = (jboolean)result; 
1276   {
1277     jint jvalue = (jint)temp5;
1278     jenv->SetIntArrayRegion(jarg5, 0, 1, &jvalue);
1279   }
1280   
1281   return jresult;
1282 }
1283
1284
1285 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jdoubleArray jarg5) {
1286   jboolean jresult = 0 ;
1287   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1288   ScicosID arg2 ;
1289   kind_t arg3 ;
1290   object_properties_t arg4 ;
1291   double *arg5 = 0 ;
1292   double temp5 ;
1293   bool result;
1294   
1295   (void)jenv;
1296   (void)jcls;
1297   (void)jarg1_;
1298   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1299   arg2 = (ScicosID)jarg2; 
1300   arg3 = (kind_t)jarg3; 
1301   arg4 = (object_properties_t)jarg4; 
1302   {
1303     if (!jarg5) {
1304       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1305       return 0;
1306     }
1307     if (jenv->GetArrayLength(jarg5) == 0) {
1308       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1309       return 0;
1310     }
1311     temp5 = (double)0;
1312     arg5 = &temp5; 
1313   }
1314   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< double >(arg2,arg3,arg4,*arg5);
1315   jresult = (jboolean)result; 
1316   {
1317     jdouble jvalue = (jdouble)temp5;
1318     jenv->SetDoubleArrayRegion(jarg5, 0, 1, &jvalue);
1319   }
1320   
1321   return jresult;
1322 }
1323
1324
1325 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jobjectArray jarg5) {
1326   jboolean jresult = 0 ;
1327   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1328   ScicosID arg2 ;
1329   kind_t arg3 ;
1330   object_properties_t arg4 ;
1331   std::string *arg5 = 0 ;
1332   std::string temp5 ;
1333   bool result;
1334   
1335   (void)jenv;
1336   (void)jcls;
1337   (void)jarg1_;
1338   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1339   arg2 = (ScicosID)jarg2; 
1340   arg3 = (kind_t)jarg3; 
1341   arg4 = (object_properties_t)jarg4; 
1342   {
1343     if (!jarg5) {
1344       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1345       return 0;
1346     }
1347     if (jenv->GetArrayLength(jarg5) == 0) {
1348       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1349       return 0;
1350     }
1351     arg5 = &temp5; 
1352     *arg5 = "";
1353   }
1354   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::string >(arg2,arg3,arg4,*arg5);
1355   jresult = (jboolean)result; 
1356   {
1357     jstring jnewstring = NULL;
1358     if (arg5) {
1359       jnewstring = jenv->NewStringUTF(arg5->c_str());
1360     }
1361     jenv->SetObjectArrayElement(jarg5, 0, jnewstring); 
1362   }
1363   return jresult;
1364 }
1365
1366
1367 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlongArray jarg5) {
1368   jboolean jresult = 0 ;
1369   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1370   ScicosID arg2 ;
1371   kind_t arg3 ;
1372   object_properties_t arg4 ;
1373   long long *arg5 = 0 ;
1374   long long temp5 ;
1375   bool result;
1376   
1377   (void)jenv;
1378   (void)jcls;
1379   (void)jarg1_;
1380   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1381   arg2 = (ScicosID)jarg2; 
1382   arg3 = (kind_t)jarg3; 
1383   arg4 = (object_properties_t)jarg4; 
1384   {
1385     if (!jarg5) {
1386       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1387       return 0;
1388     }
1389     if (jenv->GetArrayLength(jarg5) == 0) {
1390       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1391       return 0;
1392     }
1393     temp5 = (long long)0;
1394     arg5 = &temp5; 
1395   }
1396   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< ScicosID >(arg2,arg3,arg4,*arg5);
1397   jresult = (jboolean)result; 
1398   {
1399     jlong jvalue = (jlong)temp5;
1400     jenv->SetLongArrayRegion(jarg5, 0, 1, &jvalue);
1401   }
1402   
1403   return jresult;
1404 }
1405
1406
1407 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1408   jboolean jresult = 0 ;
1409   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1410   ScicosID arg2 ;
1411   kind_t arg3 ;
1412   object_properties_t arg4 ;
1413   std::vector< int > *arg5 = 0 ;
1414   bool result;
1415   
1416   (void)jenv;
1417   (void)jcls;
1418   (void)jarg1_;
1419   (void)jarg5_;
1420   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1421   arg2 = (ScicosID)jarg2; 
1422   arg3 = (kind_t)jarg3; 
1423   arg4 = (object_properties_t)jarg4; 
1424   arg5 = *(std::vector< int > **)&jarg5;
1425   if (!arg5) {
1426     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int > & reference is null");
1427     return 0;
1428   } 
1429   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::vector< int > >(arg2,arg3,arg4,*arg5);
1430   jresult = (jboolean)result; 
1431   return jresult;
1432 }
1433
1434
1435 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_16(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1436   jboolean jresult = 0 ;
1437   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1438   ScicosID arg2 ;
1439   kind_t arg3 ;
1440   object_properties_t arg4 ;
1441   std::vector< double > *arg5 = 0 ;
1442   bool result;
1443   
1444   (void)jenv;
1445   (void)jcls;
1446   (void)jarg1_;
1447   (void)jarg5_;
1448   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1449   arg2 = (ScicosID)jarg2; 
1450   arg3 = (kind_t)jarg3; 
1451   arg4 = (object_properties_t)jarg4; 
1452   arg5 = *(std::vector< double > **)&jarg5;
1453   if (!arg5) {
1454     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< double > & reference is null");
1455     return 0;
1456   } 
1457   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::vector< double > >(arg2,arg3,arg4,*arg5);
1458   jresult = (jboolean)result; 
1459   return jresult;
1460 }
1461
1462
1463 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_17(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1464   jboolean jresult = 0 ;
1465   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1466   ScicosID arg2 ;
1467   kind_t arg3 ;
1468   object_properties_t arg4 ;
1469   std::vector< std::string > *arg5 = 0 ;
1470   bool result;
1471   
1472   (void)jenv;
1473   (void)jcls;
1474   (void)jarg1_;
1475   (void)jarg5_;
1476   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1477   arg2 = (ScicosID)jarg2; 
1478   arg3 = (kind_t)jarg3; 
1479   arg4 = (object_properties_t)jarg4; 
1480   arg5 = *(std::vector< std::string > **)&jarg5;
1481   if (!arg5) {
1482     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > & reference is null");
1483     return 0;
1484   } 
1485   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::vector< std::string > >(arg2,arg3,arg4,*arg5);
1486   jresult = (jboolean)result; 
1487   return jresult;
1488 }
1489
1490
1491 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_18(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1492   jboolean jresult = 0 ;
1493   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1494   ScicosID arg2 ;
1495   kind_t arg3 ;
1496   object_properties_t arg4 ;
1497   std::vector< long long > *arg5 = 0 ;
1498   bool result;
1499   
1500   (void)jenv;
1501   (void)jcls;
1502   (void)jarg1_;
1503   (void)jarg5_;
1504   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1505   arg2 = (ScicosID)jarg2; 
1506   arg3 = (kind_t)jarg3; 
1507   arg4 = (object_properties_t)jarg4; 
1508   arg5 = *(std::vector< long long > **)&jarg5;
1509   if (!arg5) {
1510     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< long long > & reference is null");
1511     return 0;
1512   } 
1513   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::vector< ScicosID > >(arg2,arg3,arg4,*arg5);
1514   jresult = (jboolean)result; 
1515   return jresult;
1516 }
1517
1518
1519 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jint jarg5) {
1520   jint jresult = 0 ;
1521   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1522   ScicosID arg2 ;
1523   kind_t arg3 ;
1524   object_properties_t arg4 ;
1525   int arg5 ;
1526   update_status_t result;
1527   
1528   (void)jenv;
1529   (void)jcls;
1530   (void)jarg1_;
1531   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1532   arg2 = (ScicosID)jarg2; 
1533   arg3 = (kind_t)jarg3; 
1534   arg4 = (object_properties_t)jarg4; 
1535   arg5 = (int)jarg5; 
1536   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< int >(arg2,arg3,arg4,arg5);
1537   jresult = (jint)result; 
1538   return jresult;
1539 }
1540
1541
1542 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jdouble jarg5) {
1543   jint jresult = 0 ;
1544   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1545   ScicosID arg2 ;
1546   kind_t arg3 ;
1547   object_properties_t arg4 ;
1548   double arg5 ;
1549   update_status_t result;
1550   
1551   (void)jenv;
1552   (void)jcls;
1553   (void)jarg1_;
1554   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1555   arg2 = (ScicosID)jarg2; 
1556   arg3 = (kind_t)jarg3; 
1557   arg4 = (object_properties_t)jarg4; 
1558   arg5 = (double)jarg5; 
1559   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< double >(arg2,arg3,arg4,arg5);
1560   jresult = (jint)result; 
1561   return jresult;
1562 }
1563
1564
1565 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jstring jarg5) {
1566   jint jresult = 0 ;
1567   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1568   ScicosID arg2 ;
1569   kind_t arg3 ;
1570   object_properties_t arg4 ;
1571   std::string arg5 ;
1572   update_status_t result;
1573   
1574   (void)jenv;
1575   (void)jcls;
1576   (void)jarg1_;
1577   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1578   arg2 = (ScicosID)jarg2; 
1579   arg3 = (kind_t)jarg3; 
1580   arg4 = (object_properties_t)jarg4; 
1581   if(!jarg5) {
1582     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
1583     return 0;
1584   } 
1585   const char *arg5_pstr = (const char *)jenv->GetStringUTFChars(jarg5, 0); 
1586   if (!arg5_pstr) return 0;
1587   (&arg5)->assign(arg5_pstr);
1588   jenv->ReleaseStringUTFChars(jarg5, arg5_pstr); 
1589   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::string >(arg2,arg3,arg4,arg5);
1590   jresult = (jint)result; 
1591   return jresult;
1592 }
1593
1594
1595 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5) {
1596   jint jresult = 0 ;
1597   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1598   ScicosID arg2 ;
1599   kind_t arg3 ;
1600   object_properties_t arg4 ;
1601   long long arg5 ;
1602   update_status_t result;
1603   
1604   (void)jenv;
1605   (void)jcls;
1606   (void)jarg1_;
1607   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1608   arg2 = (ScicosID)jarg2; 
1609   arg3 = (kind_t)jarg3; 
1610   arg4 = (object_properties_t)jarg4; 
1611   arg5 = (long long)jarg5; 
1612   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< ScicosID >(arg2,arg3,arg4,arg5);
1613   jresult = (jint)result; 
1614   return jresult;
1615 }
1616
1617
1618 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1619   jint jresult = 0 ;
1620   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1621   ScicosID arg2 ;
1622   kind_t arg3 ;
1623   object_properties_t arg4 ;
1624   std::vector< int > arg5 ;
1625   std::vector< int > *argp5 ;
1626   update_status_t result;
1627   
1628   (void)jenv;
1629   (void)jcls;
1630   (void)jarg1_;
1631   (void)jarg5_;
1632   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1633   arg2 = (ScicosID)jarg2; 
1634   arg3 = (kind_t)jarg3; 
1635   arg4 = (object_properties_t)jarg4; 
1636   argp5 = *(std::vector< int > **)&jarg5; 
1637   if (!argp5) {
1638     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< int >");
1639     return 0;
1640   }
1641   arg5 = *argp5; 
1642   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::vector< int > >(arg2,arg3,arg4,arg5);
1643   jresult = (jint)result; 
1644   return jresult;
1645 }
1646
1647
1648 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_16(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1649   jint jresult = 0 ;
1650   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1651   ScicosID arg2 ;
1652   kind_t arg3 ;
1653   object_properties_t arg4 ;
1654   std::vector< double > arg5 ;
1655   std::vector< double > *argp5 ;
1656   update_status_t result;
1657   
1658   (void)jenv;
1659   (void)jcls;
1660   (void)jarg1_;
1661   (void)jarg5_;
1662   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1663   arg2 = (ScicosID)jarg2; 
1664   arg3 = (kind_t)jarg3; 
1665   arg4 = (object_properties_t)jarg4; 
1666   argp5 = *(std::vector< double > **)&jarg5; 
1667   if (!argp5) {
1668     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< double >");
1669     return 0;
1670   }
1671   arg5 = *argp5; 
1672   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::vector< double > >(arg2,arg3,arg4,arg5);
1673   jresult = (jint)result; 
1674   return jresult;
1675 }
1676
1677
1678 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_17(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1679   jint jresult = 0 ;
1680   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1681   ScicosID arg2 ;
1682   kind_t arg3 ;
1683   object_properties_t arg4 ;
1684   std::vector< std::string > arg5 ;
1685   std::vector< std::string > *argp5 ;
1686   update_status_t result;
1687   
1688   (void)jenv;
1689   (void)jcls;
1690   (void)jarg1_;
1691   (void)jarg5_;
1692   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1693   arg2 = (ScicosID)jarg2; 
1694   arg3 = (kind_t)jarg3; 
1695   arg4 = (object_properties_t)jarg4; 
1696   argp5 = *(std::vector< std::string > **)&jarg5; 
1697   if (!argp5) {
1698     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< std::string >");
1699     return 0;
1700   }
1701   arg5 = *argp5; 
1702   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::vector< std::string > >(arg2,arg3,arg4,arg5);
1703   jresult = (jint)result; 
1704   return jresult;
1705 }
1706
1707
1708 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_18(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1709   jint jresult = 0 ;
1710   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1711   ScicosID arg2 ;
1712   kind_t arg3 ;
1713   object_properties_t arg4 ;
1714   std::vector< long long > arg5 ;
1715   std::vector< long long > *argp5 ;
1716   update_status_t result;
1717   
1718   (void)jenv;
1719   (void)jcls;
1720   (void)jarg1_;
1721   (void)jarg5_;
1722   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1723   arg2 = (ScicosID)jarg2; 
1724   arg3 = (kind_t)jarg3; 
1725   arg4 = (object_properties_t)jarg4; 
1726   argp5 = *(std::vector< long long > **)&jarg5; 
1727   if (!argp5) {
1728     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< long long >");
1729     return 0;
1730   }
1731   arg5 = *argp5; 
1732   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::vector< ScicosID > >(arg2,arg3,arg4,arg5);
1733   jresult = (jint)result; 
1734   return jresult;
1735 }
1736
1737
1738 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfDouble_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
1739   jlong jresult = 0 ;
1740   std::vector< double > *result = 0 ;
1741   
1742   (void)jenv;
1743   (void)jcls;
1744   result = (std::vector< double > *)new std::vector< double >();
1745   *(std::vector< double > **)&jresult = result; 
1746   return jresult;
1747 }
1748
1749
1750 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfDouble_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1751   jlong jresult = 0 ;
1752   std::vector< double >::size_type arg1 ;
1753   std::vector< double > *result = 0 ;
1754   
1755   (void)jenv;
1756   (void)jcls;
1757   arg1 = (std::vector< double >::size_type)jarg1; 
1758   result = (std::vector< double > *)new std::vector< double >(arg1);
1759   *(std::vector< double > **)&jresult = result; 
1760   return jresult;
1761 }
1762
1763
1764 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1765   jlong jresult = 0 ;
1766   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1767   std::vector< double >::size_type result;
1768   
1769   (void)jenv;
1770   (void)jcls;
1771   (void)jarg1_;
1772   arg1 = *(std::vector< double > **)&jarg1; 
1773   result = ((std::vector< double > const *)arg1)->size();
1774   jresult = (jlong)result; 
1775   return jresult;
1776 }
1777
1778
1779 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1780   jlong jresult = 0 ;
1781   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1782   std::vector< double >::size_type result;
1783   
1784   (void)jenv;
1785   (void)jcls;
1786   (void)jarg1_;
1787   arg1 = *(std::vector< double > **)&jarg1; 
1788   result = ((std::vector< double > const *)arg1)->capacity();
1789   jresult = (jlong)result; 
1790   return jresult;
1791 }
1792
1793
1794 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1795   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1796   std::vector< double >::size_type arg2 ;
1797   
1798   (void)jenv;
1799   (void)jcls;
1800   (void)jarg1_;
1801   arg1 = *(std::vector< double > **)&jarg1; 
1802   arg2 = (std::vector< double >::size_type)jarg2; 
1803   (arg1)->reserve(arg2);
1804 }
1805
1806
1807 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1808   jboolean jresult = 0 ;
1809   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1810   bool result;
1811   
1812   (void)jenv;
1813   (void)jcls;
1814   (void)jarg1_;
1815   arg1 = *(std::vector< double > **)&jarg1; 
1816   result = (bool)((std::vector< double > const *)arg1)->empty();
1817   jresult = (jboolean)result; 
1818   return jresult;
1819 }
1820
1821
1822 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1823   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1824   
1825   (void)jenv;
1826   (void)jcls;
1827   (void)jarg1_;
1828   arg1 = *(std::vector< double > **)&jarg1; 
1829   (arg1)->clear();
1830 }
1831
1832
1833 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1add(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
1834   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1835   std::vector< double >::value_type *arg2 = 0 ;
1836   std::vector< double >::value_type temp2 ;
1837   
1838   (void)jenv;
1839   (void)jcls;
1840   (void)jarg1_;
1841   arg1 = *(std::vector< double > **)&jarg1; 
1842   temp2 = (std::vector< double >::value_type)jarg2; 
1843   arg2 = &temp2; 
1844   (arg1)->push_back((std::vector< double >::value_type const &)*arg2);
1845 }
1846
1847
1848 SWIGEXPORT jdouble JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
1849   jdouble jresult = 0 ;
1850   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1851   int arg2 ;
1852   std::vector< double >::value_type *result = 0 ;
1853   
1854   (void)jenv;
1855   (void)jcls;
1856   (void)jarg1_;
1857   arg1 = *(std::vector< double > **)&jarg1; 
1858   arg2 = (int)jarg2; 
1859   try {
1860     result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg__get(arg1,arg2);
1861   }
1862   catch(std::out_of_range &_e) {
1863     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
1864     return 0;
1865   }
1866   
1867   jresult = (jdouble)*result; 
1868   return jresult;
1869 }
1870
1871
1872 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jdouble jarg3) {
1873   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1874   int arg2 ;
1875   std::vector< double >::value_type *arg3 = 0 ;
1876   std::vector< double >::value_type temp3 ;
1877   
1878   (void)jenv;
1879   (void)jcls;
1880   (void)jarg1_;
1881   arg1 = *(std::vector< double > **)&jarg1; 
1882   arg2 = (int)jarg2; 
1883   temp3 = (std::vector< double >::value_type)jarg3; 
1884   arg3 = &temp3; 
1885   try {
1886     std_vector_Sl_double_Sg__set(arg1,arg2,(double const &)*arg3);
1887   }
1888   catch(std::out_of_range &_e) {
1889     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
1890     return ;
1891   }
1892   
1893 }
1894
1895
1896 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfDouble(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1897   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1898   
1899   (void)jenv;
1900   (void)jcls;
1901   arg1 = *(std::vector< double > **)&jarg1; 
1902   delete arg1;
1903 }
1904
1905
1906 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfInt_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
1907   jlong jresult = 0 ;
1908   std::vector< int > *result = 0 ;
1909   
1910   (void)jenv;
1911   (void)jcls;
1912   result = (std::vector< int > *)new std::vector< int >();
1913   *(std::vector< int > **)&jresult = result; 
1914   return jresult;
1915 }
1916
1917
1918 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfInt_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1919   jlong jresult = 0 ;
1920   std::vector< int >::size_type arg1 ;
1921   std::vector< int > *result = 0 ;
1922   
1923   (void)jenv;
1924   (void)jcls;
1925   arg1 = (std::vector< int >::size_type)jarg1; 
1926   result = (std::vector< int > *)new std::vector< int >(arg1);
1927   *(std::vector< int > **)&jresult = result; 
1928   return jresult;
1929 }
1930
1931
1932 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1933   jlong jresult = 0 ;
1934   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1935   std::vector< int >::size_type result;
1936   
1937   (void)jenv;
1938   (void)jcls;
1939   (void)jarg1_;
1940   arg1 = *(std::vector< int > **)&jarg1; 
1941   result = ((std::vector< int > const *)arg1)->size();
1942   jresult = (jlong)result; 
1943   return jresult;
1944 }
1945
1946
1947 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1948   jlong jresult = 0 ;
1949   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1950   std::vector< int >::size_type result;
1951   
1952   (void)jenv;
1953   (void)jcls;
1954   (void)jarg1_;
1955   arg1 = *(std::vector< int > **)&jarg1; 
1956   result = ((std::vector< int > const *)arg1)->capacity();
1957   jresult = (jlong)result; 
1958   return jresult;
1959 }
1960
1961
1962 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1963   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1964   std::vector< int >::size_type arg2 ;
1965   
1966   (void)jenv;
1967   (void)jcls;
1968   (void)jarg1_;
1969   arg1 = *(std::vector< int > **)&jarg1; 
1970   arg2 = (std::vector< int >::size_type)jarg2; 
1971   (arg1)->reserve(arg2);
1972 }
1973
1974
1975 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1976   jboolean jresult = 0 ;
1977   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1978   bool result;
1979   
1980   (void)jenv;
1981   (void)jcls;
1982   (void)jarg1_;
1983   arg1 = *(std::vector< int > **)&jarg1; 
1984   result = (bool)((std::vector< int > const *)arg1)->empty();
1985   jresult = (jboolean)result; 
1986   return jresult;
1987 }
1988
1989
1990 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1991   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1992   
1993   (void)jenv;
1994   (void)jcls;
1995   (void)jarg1_;
1996   arg1 = *(std::vector< int > **)&jarg1; 
1997   (arg1)->clear();
1998 }
1999
2000
2001 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1add(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2002   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2003   std::vector< int >::value_type *arg2 = 0 ;
2004   std::vector< int >::value_type temp2 ;
2005   
2006   (void)jenv;
2007   (void)jcls;
2008   (void)jarg1_;
2009   arg1 = *(std::vector< int > **)&jarg1; 
2010   temp2 = (std::vector< int >::value_type)jarg2; 
2011   arg2 = &temp2; 
2012   (arg1)->push_back((std::vector< int >::value_type const &)*arg2);
2013 }
2014
2015
2016 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2017   jint jresult = 0 ;
2018   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2019   int arg2 ;
2020   std::vector< int >::value_type *result = 0 ;
2021   
2022   (void)jenv;
2023   (void)jcls;
2024   (void)jarg1_;
2025   arg1 = *(std::vector< int > **)&jarg1; 
2026   arg2 = (int)jarg2; 
2027   try {
2028     result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg__get(arg1,arg2);
2029   }
2030   catch(std::out_of_range &_e) {
2031     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2032     return 0;
2033   }
2034   
2035   jresult = (jint)*result; 
2036   return jresult;
2037 }
2038
2039
2040 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
2041   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2042   int arg2 ;
2043   std::vector< int >::value_type *arg3 = 0 ;
2044   std::vector< int >::value_type temp3 ;
2045   
2046   (void)jenv;
2047   (void)jcls;
2048   (void)jarg1_;
2049   arg1 = *(std::vector< int > **)&jarg1; 
2050   arg2 = (int)jarg2; 
2051   temp3 = (std::vector< int >::value_type)jarg3; 
2052   arg3 = &temp3; 
2053   try {
2054     std_vector_Sl_int_Sg__set(arg1,arg2,(int const &)*arg3);
2055   }
2056   catch(std::out_of_range &_e) {
2057     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2058     return ;
2059   }
2060   
2061 }
2062
2063
2064 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfInt(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2065   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2066   
2067   (void)jenv;
2068   (void)jcls;
2069   arg1 = *(std::vector< int > **)&jarg1; 
2070   delete arg1;
2071 }
2072
2073
2074 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfBool_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2075   jlong jresult = 0 ;
2076   std::vector< bool > *result = 0 ;
2077   
2078   (void)jenv;
2079   (void)jcls;
2080   result = (std::vector< bool > *)new std::vector< bool >();
2081   *(std::vector< bool > **)&jresult = result; 
2082   return jresult;
2083 }
2084
2085
2086 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfBool_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2087   jlong jresult = 0 ;
2088   std::vector< bool >::size_type arg1 ;
2089   std::vector< bool > *result = 0 ;
2090   
2091   (void)jenv;
2092   (void)jcls;
2093   arg1 = (std::vector< bool >::size_type)jarg1; 
2094   result = (std::vector< bool > *)new std::vector< bool >(arg1);
2095   *(std::vector< bool > **)&jresult = result; 
2096   return jresult;
2097 }
2098
2099
2100 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2101   jlong jresult = 0 ;
2102   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2103   std::vector< bool >::size_type result;
2104   
2105   (void)jenv;
2106   (void)jcls;
2107   (void)jarg1_;
2108   arg1 = *(std::vector< bool > **)&jarg1; 
2109   result = ((std::vector< bool > const *)arg1)->size();
2110   jresult = (jlong)result; 
2111   return jresult;
2112 }
2113
2114
2115 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2116   jlong jresult = 0 ;
2117   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2118   std::vector< bool >::size_type result;
2119   
2120   (void)jenv;
2121   (void)jcls;
2122   (void)jarg1_;
2123   arg1 = *(std::vector< bool > **)&jarg1; 
2124   result = ((std::vector< bool > const *)arg1)->capacity();
2125   jresult = (jlong)result; 
2126   return jresult;
2127 }
2128
2129
2130 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2131   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2132   std::vector< bool >::size_type arg2 ;
2133   
2134   (void)jenv;
2135   (void)jcls;
2136   (void)jarg1_;
2137   arg1 = *(std::vector< bool > **)&jarg1; 
2138   arg2 = (std::vector< bool >::size_type)jarg2; 
2139   (arg1)->reserve(arg2);
2140 }
2141
2142
2143 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2144   jboolean jresult = 0 ;
2145   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2146   bool result;
2147   
2148   (void)jenv;
2149   (void)jcls;
2150   (void)jarg1_;
2151   arg1 = *(std::vector< bool > **)&jarg1; 
2152   result = (bool)((std::vector< bool > const *)arg1)->empty();
2153   jresult = (jboolean)result; 
2154   return jresult;
2155 }
2156
2157
2158 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2159   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2160   
2161   (void)jenv;
2162   (void)jcls;
2163   (void)jarg1_;
2164   arg1 = *(std::vector< bool > **)&jarg1; 
2165   (arg1)->clear();
2166 }
2167
2168
2169 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1add(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
2170   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2171   std::vector< bool >::value_type *arg2 = 0 ;
2172   std::vector< bool >::value_type temp2 ;
2173   
2174   (void)jenv;
2175   (void)jcls;
2176   (void)jarg1_;
2177   arg1 = *(std::vector< bool > **)&jarg1; 
2178   temp2 = jarg2 ? true : false; 
2179   arg2 = &temp2; 
2180   (arg1)->push_back((std::vector< bool >::value_type const &)*arg2);
2181 }
2182
2183
2184 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2185   jboolean jresult = 0 ;
2186   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2187   int arg2 ;
2188   bool result;
2189   
2190   (void)jenv;
2191   (void)jcls;
2192   (void)jarg1_;
2193   arg1 = *(std::vector< bool > **)&jarg1; 
2194   arg2 = (int)jarg2; 
2195   try {
2196     result = (bool)std_vector_Sl_bool_Sg__get(arg1,arg2);
2197   }
2198   catch(std::out_of_range &_e) {
2199     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2200     return 0;
2201   }
2202   
2203   jresult = (jboolean)result; 
2204   return jresult;
2205 }
2206
2207
2208 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) {
2209   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2210   int arg2 ;
2211   std::vector< bool >::value_type *arg3 = 0 ;
2212   std::vector< bool >::value_type temp3 ;
2213   
2214   (void)jenv;
2215   (void)jcls;
2216   (void)jarg1_;
2217   arg1 = *(std::vector< bool > **)&jarg1; 
2218   arg2 = (int)jarg2; 
2219   temp3 = jarg3 ? true : false; 
2220   arg3 = &temp3; 
2221   try {
2222     std_vector_Sl_bool_Sg__set(arg1,arg2,(bool const &)*arg3);
2223   }
2224   catch(std::out_of_range &_e) {
2225     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2226     return ;
2227   }
2228   
2229 }
2230
2231
2232 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfBool(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2233   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2234   
2235   (void)jenv;
2236   (void)jcls;
2237   arg1 = *(std::vector< bool > **)&jarg1; 
2238   delete arg1;
2239 }
2240
2241
2242 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfString_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2243   jlong jresult = 0 ;
2244   std::vector< std::string > *result = 0 ;
2245   
2246   (void)jenv;
2247   (void)jcls;
2248   result = (std::vector< std::string > *)new std::vector< std::string >();
2249   *(std::vector< std::string > **)&jresult = result; 
2250   return jresult;
2251 }
2252
2253
2254 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfString_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2255   jlong jresult = 0 ;
2256   std::vector< std::string >::size_type arg1 ;
2257   std::vector< std::string > *result = 0 ;
2258   
2259   (void)jenv;
2260   (void)jcls;
2261   arg1 = (std::vector< std::string >::size_type)jarg1; 
2262   result = (std::vector< std::string > *)new std::vector< std::string >(arg1);
2263   *(std::vector< std::string > **)&jresult = result; 
2264   return jresult;
2265 }
2266
2267
2268 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2269   jlong jresult = 0 ;
2270   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2271   std::vector< std::string >::size_type result;
2272   
2273   (void)jenv;
2274   (void)jcls;
2275   (void)jarg1_;
2276   arg1 = *(std::vector< std::string > **)&jarg1; 
2277   result = ((std::vector< std::string > const *)arg1)->size();
2278   jresult = (jlong)result; 
2279   return jresult;
2280 }
2281
2282
2283 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2284   jlong jresult = 0 ;
2285   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2286   std::vector< std::string >::size_type result;
2287   
2288   (void)jenv;
2289   (void)jcls;
2290   (void)jarg1_;
2291   arg1 = *(std::vector< std::string > **)&jarg1; 
2292   result = ((std::vector< std::string > const *)arg1)->capacity();
2293   jresult = (jlong)result; 
2294   return jresult;
2295 }
2296
2297
2298 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2299   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2300   std::vector< std::string >::size_type arg2 ;
2301   
2302   (void)jenv;
2303   (void)jcls;
2304   (void)jarg1_;
2305   arg1 = *(std::vector< std::string > **)&jarg1; 
2306   arg2 = (std::vector< std::string >::size_type)jarg2; 
2307   (arg1)->reserve(arg2);
2308 }
2309
2310
2311 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2312   jboolean jresult = 0 ;
2313   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2314   bool result;
2315   
2316   (void)jenv;
2317   (void)jcls;
2318   (void)jarg1_;
2319   arg1 = *(std::vector< std::string > **)&jarg1; 
2320   result = (bool)((std::vector< std::string > const *)arg1)->empty();
2321   jresult = (jboolean)result; 
2322   return jresult;
2323 }
2324
2325
2326 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2327   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2328   
2329   (void)jenv;
2330   (void)jcls;
2331   (void)jarg1_;
2332   arg1 = *(std::vector< std::string > **)&jarg1; 
2333   (arg1)->clear();
2334 }
2335
2336
2337 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1add(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
2338   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2339   std::vector< std::string >::value_type *arg2 = 0 ;
2340   
2341   (void)jenv;
2342   (void)jcls;
2343   (void)jarg1_;
2344   arg1 = *(std::vector< std::string > **)&jarg1; 
2345   if(!jarg2) {
2346     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
2347     return ;
2348   }
2349   const char *arg2_pstr = (const char *)jenv->GetStringUTFChars(jarg2, 0); 
2350   if (!arg2_pstr) return ;
2351   std::vector< std::string >::value_type arg2_str(arg2_pstr);
2352   arg2 = &arg2_str;
2353   jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
2354   (arg1)->push_back((std::vector< std::string >::value_type const &)*arg2);
2355 }
2356
2357
2358 SWIGEXPORT jstring JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2359   jstring jresult = 0 ;
2360   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2361   int arg2 ;
2362   std::vector< std::string >::value_type *result = 0 ;
2363   
2364   (void)jenv;
2365   (void)jcls;
2366   (void)jarg1_;
2367   arg1 = *(std::vector< std::string > **)&jarg1; 
2368   arg2 = (int)jarg2; 
2369   try {
2370     result = (std::vector< std::string >::value_type *) &std_vector_Sl_std_string_Sg__get(arg1,arg2);
2371   }
2372   catch(std::out_of_range &_e) {
2373     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2374     return 0;
2375   }
2376   
2377   jresult = jenv->NewStringUTF(result->c_str()); 
2378   return jresult;
2379 }
2380
2381
2382 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) {
2383   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2384   int arg2 ;
2385   std::vector< std::string >::value_type *arg3 = 0 ;
2386   
2387   (void)jenv;
2388   (void)jcls;
2389   (void)jarg1_;
2390   arg1 = *(std::vector< std::string > **)&jarg1; 
2391   arg2 = (int)jarg2; 
2392   if(!jarg3) {
2393     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
2394     return ;
2395   }
2396   const char *arg3_pstr = (const char *)jenv->GetStringUTFChars(jarg3, 0); 
2397   if (!arg3_pstr) return ;
2398   std::vector< std::string >::value_type arg3_str(arg3_pstr);
2399   arg3 = &arg3_str;
2400   jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
2401   try {
2402     std_vector_Sl_std_string_Sg__set(arg1,arg2,(std::string const &)*arg3);
2403   }
2404   catch(std::out_of_range &_e) {
2405     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2406     return ;
2407   }
2408   
2409 }
2410
2411
2412 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfString(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2413   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2414   
2415   (void)jenv;
2416   (void)jcls;
2417   arg1 = *(std::vector< std::string > **)&jarg1; 
2418   delete arg1;
2419 }
2420
2421
2422 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfScicosID_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2423   jlong jresult = 0 ;
2424   std::vector< ScicosID > *result = 0 ;
2425   
2426   (void)jenv;
2427   (void)jcls;
2428   result = (std::vector< ScicosID > *)new std::vector< ScicosID >();
2429   *(std::vector< ScicosID > **)&jresult = result; 
2430   return jresult;
2431 }
2432
2433
2434 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfScicosID_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2435   jlong jresult = 0 ;
2436   std::vector< long long >::size_type arg1 ;
2437   std::vector< ScicosID > *result = 0 ;
2438   
2439   (void)jenv;
2440   (void)jcls;
2441   arg1 = (std::vector< long long >::size_type)jarg1; 
2442   result = (std::vector< ScicosID > *)new std::vector< ScicosID >(arg1);
2443   *(std::vector< ScicosID > **)&jresult = result; 
2444   return jresult;
2445 }
2446
2447
2448 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2449   jlong jresult = 0 ;
2450   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2451   std::vector< long long >::size_type result;
2452   
2453   (void)jenv;
2454   (void)jcls;
2455   (void)jarg1_;
2456   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2457   result = ((std::vector< ScicosID > const *)arg1)->size();
2458   jresult = (jlong)result; 
2459   return jresult;
2460 }
2461
2462
2463 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2464   jlong jresult = 0 ;
2465   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2466   std::vector< long long >::size_type result;
2467   
2468   (void)jenv;
2469   (void)jcls;
2470   (void)jarg1_;
2471   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2472   result = ((std::vector< ScicosID > const *)arg1)->capacity();
2473   jresult = (jlong)result; 
2474   return jresult;
2475 }
2476
2477
2478 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2479   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2480   std::vector< long long >::size_type arg2 ;
2481   
2482   (void)jenv;
2483   (void)jcls;
2484   (void)jarg1_;
2485   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2486   arg2 = (std::vector< long long >::size_type)jarg2; 
2487   (arg1)->reserve(arg2);
2488 }
2489
2490
2491 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2492   jboolean jresult = 0 ;
2493   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2494   bool result;
2495   
2496   (void)jenv;
2497   (void)jcls;
2498   (void)jarg1_;
2499   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2500   result = (bool)((std::vector< ScicosID > const *)arg1)->empty();
2501   jresult = (jboolean)result; 
2502   return jresult;
2503 }
2504
2505
2506 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2507   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2508   
2509   (void)jenv;
2510   (void)jcls;
2511   (void)jarg1_;
2512   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2513   (arg1)->clear();
2514 }
2515
2516
2517 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1add(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2518   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2519   std::vector< long long >::value_type *arg2 = 0 ;
2520   std::vector< long long >::value_type temp2 ;
2521   
2522   (void)jenv;
2523   (void)jcls;
2524   (void)jarg1_;
2525   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2526   temp2 = (std::vector< long long >::value_type)jarg2; 
2527   arg2 = &temp2; 
2528   (arg1)->push_back((std::vector< long long >::value_type const &)*arg2);
2529 }
2530
2531
2532 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2533   jlong jresult = 0 ;
2534   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2535   int arg2 ;
2536   std::vector< long long >::value_type *result = 0 ;
2537   
2538   (void)jenv;
2539   (void)jcls;
2540   (void)jarg1_;
2541   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2542   arg2 = (int)jarg2; 
2543   try {
2544     result = (std::vector< long long >::value_type *) &std_vector_Sl_ScicosID_Sg__get(arg1,arg2);
2545   }
2546   catch(std::out_of_range &_e) {
2547     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2548     return 0;
2549   }
2550   
2551   jresult = (jlong)*result; 
2552   return jresult;
2553 }
2554
2555
2556 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
2557   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2558   int arg2 ;
2559   std::vector< long long >::value_type *arg3 = 0 ;
2560   std::vector< long long >::value_type temp3 ;
2561   
2562   (void)jenv;
2563   (void)jcls;
2564   (void)jarg1_;
2565   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2566   arg2 = (int)jarg2; 
2567   temp3 = (std::vector< long long >::value_type)jarg3; 
2568   arg3 = &temp3; 
2569   try {
2570     std_vector_Sl_ScicosID_Sg__set(arg1,arg2,(long long const &)*arg3);
2571   }
2572   catch(std::out_of_range &_e) {
2573     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2574     return ;
2575   }
2576   
2577 }
2578
2579
2580 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfScicosID(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2581   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2582   
2583   (void)jenv;
2584   (void)jcls;
2585   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2586   delete arg1;
2587 }
2588
2589
2590 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_register_1view(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_) {
2591   std::string *arg1 = 0 ;
2592   org_scilab_modules_scicos::View *arg2 = (org_scilab_modules_scicos::View *) 0 ;
2593   
2594   (void)jenv;
2595   (void)jcls;
2596   (void)jarg2_;
2597   if(!jarg1) {
2598     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
2599     return ;
2600   }
2601   const char *arg1_pstr = (const char *)jenv->GetStringUTFChars(jarg1, 0); 
2602   if (!arg1_pstr) return ;
2603   std::string arg1_str(arg1_pstr);
2604   arg1 = &arg1_str;
2605   jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
2606   arg2 = *(org_scilab_modules_scicos::View **)&jarg2; 
2607   register_view((std::string const &)*arg1,arg2);
2608 }
2609
2610
2611 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_unregister_1view(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2612   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
2613   
2614   (void)jenv;
2615   (void)jcls;
2616   (void)jarg1_;
2617   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
2618   unregister_view(arg1);
2619 }
2620
2621
2622 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_swig_1module_1init(JNIEnv *jenv, jclass jcls) {
2623   int i;
2624   
2625   static struct {
2626     const char *method;
2627     const char *signature;
2628   } methods[5] = {
2629     {
2630       "SwigDirector_View_objectCreated", "(Lorg/scilab/modules/xcos/View;JI)V" 
2631     },
2632     {
2633       "SwigDirector_View_objectReferenced", "(Lorg/scilab/modules/xcos/View;JI)V" 
2634     },
2635     {
2636       "SwigDirector_View_objectUnreferenced", "(Lorg/scilab/modules/xcos/View;JI)V" 
2637     },
2638     {
2639       "SwigDirector_View_objectDeleted", "(Lorg/scilab/modules/xcos/View;JI)V" 
2640     },
2641     {
2642       "SwigDirector_View_propertyUpdated", "(Lorg/scilab/modules/xcos/View;JIII)V" 
2643     }
2644   };
2645   Swig::jclass_JavaControllerJNI = (jclass) jenv->NewGlobalRef(jcls);
2646   if (!Swig::jclass_JavaControllerJNI) return;
2647   for (i = 0; i < (int) (sizeof(methods)/sizeof(methods[0])); ++i) {
2648     Swig::director_method_ids[i] = jenv->GetStaticMethodID(jcls, methods[i].method, methods[i].signature);
2649     if (!Swig::director_method_ids[i]) return;
2650   }
2651 }
2652
2653
2654 #ifdef __cplusplus
2655 }
2656 #endif
2657