Xcos MVC & GUI: allow to clone naked blocks (no ports)
[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 <iterator>
663 #include <algorithm>
664 #include <vector>
665 #include <string>
666
667 #include "utilities.hxx"
668 #include "View.hxx"
669 #include "Controller.hxx"
670
671
672 #include <stdexcept>
673
674
675 #include <string>
676
677 SWIGINTERN bool std_vector_Sl_int_Sg__contains(std::vector< int > *self,int const &o){
678                return std::find(self->begin(), self->end(), o) != self->end();
679             }
680 SWIGINTERN int std_vector_Sl_int_Sg__indexOf(std::vector< int > *self,int const &o){
681                auto it = std::find(self->begin(), self->end(), o);
682                if (it != self->end())
683                    return std::distance(self->begin(), it);
684                else
685                    return -1;
686             }
687 SWIGINTERN std::vector< int >::const_reference std_vector_Sl_int_Sg__get(std::vector< int > *self,int i){
688                 int size = int(self->size());
689                 if (i>=0 && i<size)
690                     return (*self)[i];
691                 else
692                     throw std::out_of_range("vector index out of range");
693             }
694 SWIGINTERN void std_vector_Sl_int_Sg__set(std::vector< int > *self,int i,std::vector< int >::value_type const &val){
695                 int size = int(self->size());
696                 if (i>=0 && i<size)
697                     (*self)[i] = val;
698                 else
699                     throw std::out_of_range("vector index out of range");
700             }
701 SWIGINTERN void std_vector_Sl_int_Sg__add__SWIG_1(std::vector< int > *self,int i,std::vector< int >::value_type const &val){
702                 int size = int(self->size());
703                 if (i>=0 && i<=size)
704                     self->insert(self->begin() + i, val);
705                 else
706                     throw std::out_of_range("vector index out of range");
707             }
708 SWIGINTERN bool std_vector_Sl_int_Sg__remove(std::vector< int > *self,std::vector< int >::value_type const &val){
709                 auto it = std::find(self->begin(), self->end(), val);
710                 if (it == self->end())
711                     return false;
712                 else
713                     self->erase(it);
714                 return true;
715             }
716 SWIGINTERN bool std_vector_Sl_bool_Sg__get(std::vector< bool > *self,int i){
717                 int size = int(self->size());
718                 if (i>=0 && i<size)
719                     return (*self)[i];
720                 else
721                     throw std::out_of_range("vector index out of range");
722             }
723 SWIGINTERN void std_vector_Sl_bool_Sg__set(std::vector< bool > *self,int i,std::vector< bool >::value_type const &val){
724                 int size = int(self->size());
725                 if (i>=0 && i<size)
726                     (*self)[i] = val;
727                 else
728                     throw std::out_of_range("vector index out of range");
729             }
730 SWIGINTERN void std_vector_Sl_bool_Sg__add__SWIG_1(std::vector< bool > *self,int i,std::vector< bool >::value_type const &val){
731                 int size = int(self->size());
732                 if (i>=0 && i<=size)
733                     self->insert(self->begin() + i, val);
734                 else
735                     throw std::out_of_range("vector index out of range");
736             }
737 SWIGINTERN bool std_vector_Sl_bool_Sg__remove(std::vector< bool > *self,std::vector< bool >::value_type const &val){
738                 auto it = std::find(self->begin(), self->end(), val);
739                 if (it == self->end())
740                     return false;
741                 else
742                     self->erase(it);
743                 return true;
744             }
745 SWIGINTERN bool std_vector_Sl_double_Sg__contains(std::vector< double > *self,double const &o){
746                return std::find(self->begin(), self->end(), o) != self->end();
747             }
748 SWIGINTERN int std_vector_Sl_double_Sg__indexOf(std::vector< double > *self,double const &o){
749                auto it = std::find(self->begin(), self->end(), o);
750                if (it != self->end())
751                    return std::distance(self->begin(), it);
752                else
753                    return -1;
754             }
755 SWIGINTERN std::vector< double >::const_reference std_vector_Sl_double_Sg__get(std::vector< double > *self,int i){
756                 int size = int(self->size());
757                 if (i>=0 && i<size)
758                     return (*self)[i];
759                 else
760                     throw std::out_of_range("vector index out of range");
761             }
762 SWIGINTERN void std_vector_Sl_double_Sg__set(std::vector< double > *self,int i,std::vector< double >::value_type const &val){
763                 int size = int(self->size());
764                 if (i>=0 && i<size)
765                     (*self)[i] = val;
766                 else
767                     throw std::out_of_range("vector index out of range");
768             }
769 SWIGINTERN void std_vector_Sl_double_Sg__add__SWIG_1(std::vector< double > *self,int i,std::vector< double >::value_type const &val){
770                 int size = int(self->size());
771                 if (i>=0 && i<=size)
772                     self->insert(self->begin() + i, val);
773                 else
774                     throw std::out_of_range("vector index out of range");
775             }
776 SWIGINTERN bool std_vector_Sl_double_Sg__remove(std::vector< double > *self,std::vector< double >::value_type const &val){
777                 auto it = std::find(self->begin(), self->end(), val);
778                 if (it == self->end())
779                     return false;
780                 else
781                     self->erase(it);
782                 return true;
783             }
784 SWIGINTERN bool std_vector_Sl_std_string_Sg__contains(std::vector< std::string > *self,std::string const &o){
785                return std::find(self->begin(), self->end(), o) != self->end();
786             }
787 SWIGINTERN int std_vector_Sl_std_string_Sg__indexOf(std::vector< std::string > *self,std::string const &o){
788                auto it = std::find(self->begin(), self->end(), o);
789                if (it != self->end())
790                    return std::distance(self->begin(), it);
791                else
792                    return -1;
793             }
794 SWIGINTERN std::vector< std::string >::const_reference std_vector_Sl_std_string_Sg__get(std::vector< std::string > *self,int i){
795                 int size = int(self->size());
796                 if (i>=0 && i<size)
797                     return (*self)[i];
798                 else
799                     throw std::out_of_range("vector index out of range");
800             }
801 SWIGINTERN void std_vector_Sl_std_string_Sg__set(std::vector< std::string > *self,int i,std::vector< std::string >::value_type const &val){
802                 int size = int(self->size());
803                 if (i>=0 && i<size)
804                     (*self)[i] = val;
805                 else
806                     throw std::out_of_range("vector index out of range");
807             }
808 SWIGINTERN void std_vector_Sl_std_string_Sg__add__SWIG_1(std::vector< std::string > *self,int i,std::vector< std::string >::value_type const &val){
809                 int size = int(self->size());
810                 if (i>=0 && i<=size)
811                     self->insert(self->begin() + i, val);
812                 else
813                     throw std::out_of_range("vector index out of range");
814             }
815 SWIGINTERN bool std_vector_Sl_std_string_Sg__remove(std::vector< std::string > *self,std::vector< std::string >::value_type const &val){
816                 auto it = std::find(self->begin(), self->end(), val);
817                 if (it == self->end())
818                     return false;
819                 else
820                     self->erase(it);
821                 return true;
822             }
823 SWIGINTERN bool std_vector_Sl_ScicosID_Sg__contains(std::vector< ScicosID > *self,long long const &o){
824                return std::find(self->begin(), self->end(), o) != self->end();
825             }
826 SWIGINTERN int std_vector_Sl_ScicosID_Sg__indexOf(std::vector< ScicosID > *self,long long const &o){
827                auto it = std::find(self->begin(), self->end(), o);
828                if (it != self->end())
829                    return std::distance(self->begin(), it);
830                else
831                    return -1;
832             }
833 SWIGINTERN std::vector< long long >::const_reference std_vector_Sl_ScicosID_Sg__get(std::vector< ScicosID > *self,int i){
834                 int size = int(self->size());
835                 if (i>=0 && i<size)
836                     return (*self)[i];
837                 else
838                     throw std::out_of_range("vector index out of range");
839             }
840 SWIGINTERN void std_vector_Sl_ScicosID_Sg__set(std::vector< ScicosID > *self,int i,std::vector< long long >::value_type const &val){
841                 int size = int(self->size());
842                 if (i>=0 && i<size)
843                     (*self)[i] = val;
844                 else
845                     throw std::out_of_range("vector index out of range");
846             }
847 SWIGINTERN void std_vector_Sl_ScicosID_Sg__add__SWIG_1(std::vector< ScicosID > *self,int i,std::vector< long long >::value_type const &val){
848                 int size = int(self->size());
849                 if (i>=0 && i<=size)
850                     self->insert(self->begin() + i, val);
851                 else
852                     throw std::out_of_range("vector index out of range");
853             }
854 SWIGINTERN bool std_vector_Sl_ScicosID_Sg__remove(std::vector< ScicosID > *self,std::vector< long long >::value_type const &val){
855                 auto it = std::find(self->begin(), self->end(), val);
856                 if (it == self->end())
857                     return false;
858                 else
859                     self->erase(it);
860                 return true;
861             }
862
863 static void register_view(const std::string& name, org_scilab_modules_scicos::View* view) {
864   org_scilab_modules_scicos::Controller::register_view(name, view);
865 };
866 static void unregister_view(org_scilab_modules_scicos::View* view) {
867   org_scilab_modules_scicos::Controller::unregister_view(view);
868 };
869
870
871
872 /* ---------------------------------------------------
873  * C++ director class methods
874  * --------------------------------------------------- */
875
876 #include "JavaController_wrap.h"
877
878 SwigDirector_View::SwigDirector_View(JNIEnv *jenv) : org_scilab_modules_scicos::View(), Swig::Director(jenv) {
879 }
880
881 SwigDirector_View::~SwigDirector_View() {
882   swig_disconnect_director_self("swigDirectorDisconnect");
883 }
884
885
886 void SwigDirector_View::objectCreated(ScicosID const &uid, kind_t kind) {
887   JNIEnvWrapper swigjnienv(this) ;
888   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
889   jobject swigjobj = (jobject) NULL ;
890   jlong juid = 0 ;
891   jint jkind  ;
892   
893   if (!swig_override[0]) {
894     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectCreated.");
895     return;
896   }
897   swigjobj = swig_get_self(jenv);
898   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
899     juid = (jlong)uid;
900     jkind = (jint) kind;
901     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[0], swigjobj, juid, jkind);
902     jthrowable swigerror = jenv->ExceptionOccurred();
903     if (swigerror) {
904       jenv->ExceptionClear();
905       throw Swig::DirectorException(jenv, swigerror);
906     }
907     
908   } else {
909     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectCreated ");
910   }
911   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
912 }
913
914 void SwigDirector_View::objectReferenced(ScicosID const &uid, kind_t kind, unsigned int refCount) {
915   JNIEnvWrapper swigjnienv(this) ;
916   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
917   jobject swigjobj = (jobject) NULL ;
918   jlong juid = 0 ;
919   jint jkind  ;
920   jlong jrefCount  ;
921   
922   if (!swig_override[1]) {
923     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectReferenced.");
924     return;
925   }
926   swigjobj = swig_get_self(jenv);
927   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
928     juid = (jlong)uid;
929     jkind = (jint) kind;
930     jrefCount = (jlong) refCount;
931     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[1], swigjobj, juid, jkind, jrefCount);
932     jthrowable swigerror = jenv->ExceptionOccurred();
933     if (swigerror) {
934       jenv->ExceptionClear();
935       throw Swig::DirectorException(jenv, swigerror);
936     }
937     
938   } else {
939     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectReferenced ");
940   }
941   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
942 }
943
944 void SwigDirector_View::objectUnreferenced(ScicosID const &uid, kind_t kind, unsigned int refCount) {
945   JNIEnvWrapper swigjnienv(this) ;
946   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
947   jobject swigjobj = (jobject) NULL ;
948   jlong juid = 0 ;
949   jint jkind  ;
950   jlong jrefCount  ;
951   
952   if (!swig_override[2]) {
953     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectUnreferenced.");
954     return;
955   }
956   swigjobj = swig_get_self(jenv);
957   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
958     juid = (jlong)uid;
959     jkind = (jint) kind;
960     jrefCount = (jlong) refCount;
961     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[2], swigjobj, juid, jkind, jrefCount);
962     jthrowable swigerror = jenv->ExceptionOccurred();
963     if (swigerror) {
964       jenv->ExceptionClear();
965       throw Swig::DirectorException(jenv, swigerror);
966     }
967     
968   } else {
969     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectUnreferenced ");
970   }
971   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
972 }
973
974 void SwigDirector_View::objectDeleted(ScicosID const &uid, kind_t kind) {
975   JNIEnvWrapper swigjnienv(this) ;
976   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
977   jobject swigjobj = (jobject) NULL ;
978   jlong juid = 0 ;
979   jint jkind  ;
980   
981   if (!swig_override[3]) {
982     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectDeleted.");
983     return;
984   }
985   swigjobj = swig_get_self(jenv);
986   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
987     juid = (jlong)uid;
988     jkind = (jint) kind;
989     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[3], swigjobj, juid, jkind);
990     jthrowable swigerror = jenv->ExceptionOccurred();
991     if (swigerror) {
992       jenv->ExceptionClear();
993       throw Swig::DirectorException(jenv, swigerror);
994     }
995     
996   } else {
997     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectDeleted ");
998   }
999   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1000 }
1001
1002 void SwigDirector_View::propertyUpdated(ScicosID const &uid, kind_t kind, object_properties_t property, update_status_t status) {
1003   JNIEnvWrapper swigjnienv(this) ;
1004   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1005   jobject swigjobj = (jobject) NULL ;
1006   jlong juid = 0 ;
1007   jint jkind  ;
1008   jint jproperty  ;
1009   jint jstatus  ;
1010   
1011   if (!swig_override[4]) {
1012     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::propertyUpdated.");
1013     return;
1014   }
1015   swigjobj = swig_get_self(jenv);
1016   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1017     juid = (jlong)uid;
1018     jkind = (jint) kind;
1019     jproperty = (jint) property;
1020     jstatus = (jint) status;
1021     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[4], swigjobj, juid, jkind, jproperty, jstatus);
1022     jthrowable swigerror = jenv->ExceptionOccurred();
1023     if (swigerror) {
1024       jenv->ExceptionClear();
1025       throw Swig::DirectorException(jenv, swigerror);
1026     }
1027     
1028   } else {
1029     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::propertyUpdated ");
1030   }
1031   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1032 }
1033
1034 void SwigDirector_View::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {
1035   static struct {
1036     const char *mname;
1037     const char *mdesc;
1038     jmethodID base_methid;
1039   } methods[] = {
1040     {
1041       "objectCreated", "(JLorg/scilab/modules/xcos/Kind;)V", NULL 
1042     },
1043     {
1044       "objectReferenced", "(JLorg/scilab/modules/xcos/Kind;J)V", NULL 
1045     },
1046     {
1047       "objectUnreferenced", "(JLorg/scilab/modules/xcos/Kind;J)V", NULL 
1048     },
1049     {
1050       "objectDeleted", "(JLorg/scilab/modules/xcos/Kind;)V", NULL 
1051     },
1052     {
1053       "propertyUpdated", "(JLorg/scilab/modules/xcos/Kind;Lorg/scilab/modules/xcos/ObjectProperties;Lorg/scilab/modules/xcos/UpdateStatus;)V", NULL 
1054     }
1055   };
1056   
1057   static jclass baseclass = 0 ;
1058   
1059   if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
1060     if (!baseclass) {
1061       baseclass = jenv->FindClass("org/scilab/modules/xcos/View");
1062       if (!baseclass) return;
1063       baseclass = (jclass) jenv->NewGlobalRef(baseclass);
1064     }
1065     bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
1066     for (int i = 0; i < 5; ++i) {
1067       if (!methods[i].base_methid) {
1068         methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);
1069         if (!methods[i].base_methid) return;
1070       }
1071       swig_override[i] = false;
1072       if (derived) {
1073         jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);
1074         swig_override[i] = (methid != methods[i].base_methid);
1075         jenv->ExceptionClear();
1076       }
1077     }
1078   }
1079 }
1080
1081
1082
1083 #ifdef __cplusplus
1084 extern "C" {
1085 #endif
1086
1087 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1View(JNIEnv *jenv, jclass jcls) {
1088   jlong jresult = 0 ;
1089   org_scilab_modules_scicos::View *result = 0 ;
1090   
1091   (void)jenv;
1092   (void)jcls;
1093   result = (org_scilab_modules_scicos::View *)new SwigDirector_View(jenv);
1094   *(org_scilab_modules_scicos::View **)&jresult = result; 
1095   return jresult;
1096 }
1097
1098
1099 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1View(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1100   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1101   
1102   (void)jenv;
1103   (void)jcls;
1104   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1105   delete arg1;
1106 }
1107
1108
1109 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectCreated(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) {
1110   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1111   ScicosID *arg2 = 0 ;
1112   kind_t arg3 ;
1113   ScicosID temp2 ;
1114   
1115   (void)jenv;
1116   (void)jcls;
1117   (void)jarg1_;
1118   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1119   temp2 = (ScicosID)jarg2; 
1120   arg2 = &temp2; 
1121   arg3 = (kind_t)jarg3; 
1122   (arg1)->objectCreated((ScicosID const &)*arg2,arg3);
1123 }
1124
1125
1126 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectReferenced(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jlong jarg4) {
1127   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1128   ScicosID *arg2 = 0 ;
1129   kind_t arg3 ;
1130   unsigned int arg4 ;
1131   ScicosID temp2 ;
1132   
1133   (void)jenv;
1134   (void)jcls;
1135   (void)jarg1_;
1136   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1137   temp2 = (ScicosID)jarg2; 
1138   arg2 = &temp2; 
1139   arg3 = (kind_t)jarg3; 
1140   arg4 = (unsigned int)jarg4; 
1141   (arg1)->objectReferenced((ScicosID const &)*arg2,arg3,arg4);
1142 }
1143
1144
1145 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectUnreferenced(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jlong jarg4) {
1146   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1147   ScicosID *arg2 = 0 ;
1148   kind_t arg3 ;
1149   unsigned int arg4 ;
1150   ScicosID temp2 ;
1151   
1152   (void)jenv;
1153   (void)jcls;
1154   (void)jarg1_;
1155   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1156   temp2 = (ScicosID)jarg2; 
1157   arg2 = &temp2; 
1158   arg3 = (kind_t)jarg3; 
1159   arg4 = (unsigned int)jarg4; 
1160   (arg1)->objectUnreferenced((ScicosID const &)*arg2,arg3,arg4);
1161 }
1162
1163
1164 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectDeleted(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) {
1165   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1166   ScicosID *arg2 = 0 ;
1167   kind_t arg3 ;
1168   ScicosID temp2 ;
1169   
1170   (void)jenv;
1171   (void)jcls;
1172   (void)jarg1_;
1173   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1174   temp2 = (ScicosID)jarg2; 
1175   arg2 = &temp2; 
1176   arg3 = (kind_t)jarg3; 
1177   (arg1)->objectDeleted((ScicosID const &)*arg2,arg3);
1178 }
1179
1180
1181 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) {
1182   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1183   ScicosID *arg2 = 0 ;
1184   kind_t arg3 ;
1185   object_properties_t arg4 ;
1186   update_status_t arg5 ;
1187   ScicosID temp2 ;
1188   
1189   (void)jenv;
1190   (void)jcls;
1191   (void)jarg1_;
1192   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1193   temp2 = (ScicosID)jarg2; 
1194   arg2 = &temp2; 
1195   arg3 = (kind_t)jarg3; 
1196   arg4 = (object_properties_t)jarg4; 
1197   arg5 = (update_status_t)jarg5; 
1198   (arg1)->propertyUpdated((ScicosID const &)*arg2,arg3,arg4,arg5);
1199 }
1200
1201
1202 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) {
1203   org_scilab_modules_scicos::View *obj = *((org_scilab_modules_scicos::View **)&objarg);
1204   (void)jcls;
1205   SwigDirector_View *director = dynamic_cast<SwigDirector_View *>(obj);
1206   if (director) {
1207     director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));
1208   }
1209 }
1210
1211
1212 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {
1213   org_scilab_modules_scicos::View *obj = *((org_scilab_modules_scicos::View **)&objarg);
1214   SwigDirector_View *director = dynamic_cast<SwigDirector_View *>(obj);
1215   (void)jcls;
1216   if (director) {
1217     director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);
1218   }
1219 }
1220
1221
1222 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1look_1for_1view(JNIEnv *jenv, jclass jcls, jstring jarg1) {
1223   jlong jresult = 0 ;
1224   std::string *arg1 = 0 ;
1225   org_scilab_modules_scicos::View *result = 0 ;
1226   
1227   (void)jenv;
1228   (void)jcls;
1229   if(!jarg1) {
1230     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
1231     return 0;
1232   }
1233   const char *arg1_pstr = (const char *)jenv->GetStringUTFChars(jarg1, 0); 
1234   if (!arg1_pstr) return 0;
1235   std::string arg1_str(arg1_pstr);
1236   arg1 = &arg1_str;
1237   jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
1238   result = (org_scilab_modules_scicos::View *)org_scilab_modules_scicos::Controller::look_for_view((std::string const &)*arg1);
1239   *(org_scilab_modules_scicos::View **)&jresult = result; 
1240   return jresult;
1241 }
1242
1243
1244 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1Controller(JNIEnv *jenv, jclass jcls) {
1245   jlong jresult = 0 ;
1246   org_scilab_modules_scicos::Controller *result = 0 ;
1247   
1248   (void)jenv;
1249   (void)jcls;
1250   result = (org_scilab_modules_scicos::Controller *)new org_scilab_modules_scicos::Controller();
1251   *(org_scilab_modules_scicos::Controller **)&jresult = result; 
1252   return jresult;
1253 }
1254
1255
1256 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1Controller(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1257   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1258   
1259   (void)jenv;
1260   (void)jcls;
1261   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1262   delete arg1;
1263 }
1264
1265
1266 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1createObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
1267   jlong jresult = 0 ;
1268   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1269   kind_t arg2 ;
1270   ScicosID result;
1271   
1272   (void)jenv;
1273   (void)jcls;
1274   (void)jarg1_;
1275   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1276   arg2 = (kind_t)jarg2; 
1277   result = (ScicosID)(arg1)->createObject(arg2);
1278   jresult = (jlong)result; 
1279   return jresult;
1280 }
1281
1282
1283 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1referenceObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1284   jlong jresult = 0 ;
1285   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1286   ScicosID arg2 ;
1287   unsigned int result;
1288   
1289   (void)jenv;
1290   (void)jcls;
1291   (void)jarg1_;
1292   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1293   arg2 = (ScicosID)jarg2; 
1294   result = (unsigned int)((org_scilab_modules_scicos::Controller const *)arg1)->referenceObject(arg2);
1295   jresult = (jlong)result; 
1296   return jresult;
1297 }
1298
1299
1300 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1deleteObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1301   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1302   ScicosID arg2 ;
1303   
1304   (void)jenv;
1305   (void)jcls;
1306   (void)jarg1_;
1307   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1308   arg2 = (ScicosID)jarg2; 
1309   (arg1)->deleteObject(arg2);
1310 }
1311
1312
1313 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1cloneObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jboolean jarg3, jboolean jarg4) {
1314   jlong jresult = 0 ;
1315   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1316   ScicosID arg2 ;
1317   bool arg3 ;
1318   bool arg4 ;
1319   ScicosID result;
1320   
1321   (void)jenv;
1322   (void)jcls;
1323   (void)jarg1_;
1324   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1325   arg2 = (ScicosID)jarg2; 
1326   arg3 = jarg3 ? true : false; 
1327   arg4 = jarg4 ? true : false; 
1328   result = (ScicosID)(arg1)->cloneObject(arg2,arg3,arg4);
1329   jresult = (jlong)result; 
1330   return jresult;
1331 }
1332
1333
1334 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getKind(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1335   jint jresult = 0 ;
1336   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1337   ScicosID arg2 ;
1338   kind_t result;
1339   
1340   (void)jenv;
1341   (void)jcls;
1342   (void)jarg1_;
1343   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1344   arg2 = (ScicosID)jarg2; 
1345   result = (kind_t)((org_scilab_modules_scicos::Controller const *)arg1)->getKind(arg2);
1346   jresult = (jint)result; 
1347   return jresult;
1348 }
1349
1350
1351 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getAll(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
1352   jlong jresult = 0 ;
1353   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1354   kind_t arg2 ;
1355   std::vector< ScicosID > result;
1356   
1357   (void)jenv;
1358   (void)jcls;
1359   (void)jarg1_;
1360   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1361   arg2 = (kind_t)jarg2; 
1362   result = ((org_scilab_modules_scicos::Controller const *)arg1)->getAll(arg2);
1363   *(std::vector< ScicosID > **)&jresult = new std::vector< ScicosID >((const std::vector< ScicosID > &)result); 
1364   return jresult;
1365 }
1366
1367
1368 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) {
1369   jboolean jresult = 0 ;
1370   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1371   ScicosID arg2 ;
1372   kind_t arg3 ;
1373   object_properties_t arg4 ;
1374   int *arg5 = 0 ;
1375   int temp5 ;
1376   bool result;
1377   
1378   (void)jenv;
1379   (void)jcls;
1380   (void)jarg1_;
1381   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1382   arg2 = (ScicosID)jarg2; 
1383   arg3 = (kind_t)jarg3; 
1384   arg4 = (object_properties_t)jarg4; 
1385   {
1386     if (!jarg5) {
1387       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1388       return 0;
1389     }
1390     if (jenv->GetArrayLength(jarg5) == 0) {
1391       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1392       return 0;
1393     }
1394     temp5 = (int)0;
1395     arg5 = &temp5; 
1396   }
1397   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< int >(arg2,arg3,arg4,*arg5);
1398   jresult = (jboolean)result; 
1399   {
1400     jint jvalue = (jint)temp5;
1401     jenv->SetIntArrayRegion(jarg5, 0, 1, &jvalue);
1402   }
1403   
1404   return jresult;
1405 }
1406
1407
1408 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, jbooleanArray jarg5) {
1409   jboolean jresult = 0 ;
1410   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1411   ScicosID arg2 ;
1412   kind_t arg3 ;
1413   object_properties_t arg4 ;
1414   bool *arg5 = 0 ;
1415   bool temp5 ;
1416   bool result;
1417   
1418   (void)jenv;
1419   (void)jcls;
1420   (void)jarg1_;
1421   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1422   arg2 = (ScicosID)jarg2; 
1423   arg3 = (kind_t)jarg3; 
1424   arg4 = (object_properties_t)jarg4; 
1425   {
1426     if (!jarg5) {
1427       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1428       return 0;
1429     }
1430     if (jenv->GetArrayLength(jarg5) == 0) {
1431       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1432       return 0;
1433     }
1434     temp5 = false;
1435     arg5 = &temp5; 
1436   }
1437   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< bool >(arg2,arg3,arg4,*arg5);
1438   jresult = (jboolean)result; 
1439   {
1440     jboolean jvalue = (jboolean)temp5;
1441     jenv->SetBooleanArrayRegion(jarg5, 0, 1, &jvalue);
1442   }
1443   
1444   return jresult;
1445 }
1446
1447
1448 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, jdoubleArray jarg5) {
1449   jboolean jresult = 0 ;
1450   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1451   ScicosID arg2 ;
1452   kind_t arg3 ;
1453   object_properties_t arg4 ;
1454   double *arg5 = 0 ;
1455   double temp5 ;
1456   bool result;
1457   
1458   (void)jenv;
1459   (void)jcls;
1460   (void)jarg1_;
1461   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1462   arg2 = (ScicosID)jarg2; 
1463   arg3 = (kind_t)jarg3; 
1464   arg4 = (object_properties_t)jarg4; 
1465   {
1466     if (!jarg5) {
1467       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1468       return 0;
1469     }
1470     if (jenv->GetArrayLength(jarg5) == 0) {
1471       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1472       return 0;
1473     }
1474     temp5 = (double)0;
1475     arg5 = &temp5; 
1476   }
1477   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< double >(arg2,arg3,arg4,*arg5);
1478   jresult = (jboolean)result; 
1479   {
1480     jdouble jvalue = (jdouble)temp5;
1481     jenv->SetDoubleArrayRegion(jarg5, 0, 1, &jvalue);
1482   }
1483   
1484   return jresult;
1485 }
1486
1487
1488 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, jobjectArray jarg5) {
1489   jboolean jresult = 0 ;
1490   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1491   ScicosID arg2 ;
1492   kind_t arg3 ;
1493   object_properties_t arg4 ;
1494   std::string *arg5 = 0 ;
1495   std::string temp5 ;
1496   bool result;
1497   
1498   (void)jenv;
1499   (void)jcls;
1500   (void)jarg1_;
1501   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1502   arg2 = (ScicosID)jarg2; 
1503   arg3 = (kind_t)jarg3; 
1504   arg4 = (object_properties_t)jarg4; 
1505   {
1506     if (!jarg5) {
1507       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1508       return 0;
1509     }
1510     if (jenv->GetArrayLength(jarg5) == 0) {
1511       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1512       return 0;
1513     }
1514     arg5 = &temp5; 
1515     *arg5 = "";
1516   }
1517   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::string >(arg2,arg3,arg4,*arg5);
1518   jresult = (jboolean)result; 
1519   {
1520     jstring jnewstring = NULL;
1521     if (arg5) {
1522       jnewstring = jenv->NewStringUTF(arg5->c_str());
1523     }
1524     jenv->SetObjectArrayElement(jarg5, 0, jnewstring); 
1525   }
1526   return jresult;
1527 }
1528
1529
1530 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, jlongArray jarg5) {
1531   jboolean jresult = 0 ;
1532   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1533   ScicosID arg2 ;
1534   kind_t arg3 ;
1535   object_properties_t arg4 ;
1536   long long *arg5 = 0 ;
1537   long long temp5 ;
1538   bool result;
1539   
1540   (void)jenv;
1541   (void)jcls;
1542   (void)jarg1_;
1543   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1544   arg2 = (ScicosID)jarg2; 
1545   arg3 = (kind_t)jarg3; 
1546   arg4 = (object_properties_t)jarg4; 
1547   {
1548     if (!jarg5) {
1549       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1550       return 0;
1551     }
1552     if (jenv->GetArrayLength(jarg5) == 0) {
1553       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1554       return 0;
1555     }
1556     temp5 = (long long)0;
1557     arg5 = &temp5; 
1558   }
1559   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< ScicosID >(arg2,arg3,arg4,*arg5);
1560   jresult = (jboolean)result; 
1561   {
1562     jlong jvalue = (jlong)temp5;
1563     jenv->SetLongArrayRegion(jarg5, 0, 1, &jvalue);
1564   }
1565   
1566   return jresult;
1567 }
1568
1569
1570 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_) {
1571   jboolean jresult = 0 ;
1572   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1573   ScicosID arg2 ;
1574   kind_t arg3 ;
1575   object_properties_t arg4 ;
1576   std::vector< int > *arg5 = 0 ;
1577   bool result;
1578   
1579   (void)jenv;
1580   (void)jcls;
1581   (void)jarg1_;
1582   (void)jarg5_;
1583   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1584   arg2 = (ScicosID)jarg2; 
1585   arg3 = (kind_t)jarg3; 
1586   arg4 = (object_properties_t)jarg4; 
1587   arg5 = *(std::vector< int > **)&jarg5;
1588   if (!arg5) {
1589     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int > & reference is null");
1590     return 0;
1591   } 
1592   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::vector< int > >(arg2,arg3,arg4,*arg5);
1593   jresult = (jboolean)result; 
1594   return jresult;
1595 }
1596
1597
1598 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_) {
1599   jboolean jresult = 0 ;
1600   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1601   ScicosID arg2 ;
1602   kind_t arg3 ;
1603   object_properties_t arg4 ;
1604   std::vector< bool > *arg5 = 0 ;
1605   bool result;
1606   
1607   (void)jenv;
1608   (void)jcls;
1609   (void)jarg1_;
1610   (void)jarg5_;
1611   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1612   arg2 = (ScicosID)jarg2; 
1613   arg3 = (kind_t)jarg3; 
1614   arg4 = (object_properties_t)jarg4; 
1615   arg5 = *(std::vector< bool > **)&jarg5;
1616   if (!arg5) {
1617     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< bool > & reference is null");
1618     return 0;
1619   } 
1620   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::vector< bool > >(arg2,arg3,arg4,*arg5);
1621   jresult = (jboolean)result; 
1622   return jresult;
1623 }
1624
1625
1626 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_) {
1627   jboolean jresult = 0 ;
1628   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1629   ScicosID arg2 ;
1630   kind_t arg3 ;
1631   object_properties_t arg4 ;
1632   std::vector< double > *arg5 = 0 ;
1633   bool result;
1634   
1635   (void)jenv;
1636   (void)jcls;
1637   (void)jarg1_;
1638   (void)jarg5_;
1639   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1640   arg2 = (ScicosID)jarg2; 
1641   arg3 = (kind_t)jarg3; 
1642   arg4 = (object_properties_t)jarg4; 
1643   arg5 = *(std::vector< double > **)&jarg5;
1644   if (!arg5) {
1645     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< double > & reference is null");
1646     return 0;
1647   } 
1648   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::vector< double > >(arg2,arg3,arg4,*arg5);
1649   jresult = (jboolean)result; 
1650   return jresult;
1651 }
1652
1653
1654 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_19(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1655   jboolean jresult = 0 ;
1656   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1657   ScicosID arg2 ;
1658   kind_t arg3 ;
1659   object_properties_t arg4 ;
1660   std::vector< std::string > *arg5 = 0 ;
1661   bool result;
1662   
1663   (void)jenv;
1664   (void)jcls;
1665   (void)jarg1_;
1666   (void)jarg5_;
1667   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1668   arg2 = (ScicosID)jarg2; 
1669   arg3 = (kind_t)jarg3; 
1670   arg4 = (object_properties_t)jarg4; 
1671   arg5 = *(std::vector< std::string > **)&jarg5;
1672   if (!arg5) {
1673     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > & reference is null");
1674     return 0;
1675   } 
1676   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::vector< std::string > >(arg2,arg3,arg4,*arg5);
1677   jresult = (jboolean)result; 
1678   return jresult;
1679 }
1680
1681
1682 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_110(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1683   jboolean jresult = 0 ;
1684   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1685   ScicosID arg2 ;
1686   kind_t arg3 ;
1687   object_properties_t arg4 ;
1688   std::vector< long long > *arg5 = 0 ;
1689   bool result;
1690   
1691   (void)jenv;
1692   (void)jcls;
1693   (void)jarg1_;
1694   (void)jarg5_;
1695   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1696   arg2 = (ScicosID)jarg2; 
1697   arg3 = (kind_t)jarg3; 
1698   arg4 = (object_properties_t)jarg4; 
1699   arg5 = *(std::vector< long long > **)&jarg5;
1700   if (!arg5) {
1701     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< long long > & reference is null");
1702     return 0;
1703   } 
1704   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::vector< ScicosID > >(arg2,arg3,arg4,*arg5);
1705   jresult = (jboolean)result; 
1706   return jresult;
1707 }
1708
1709
1710 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) {
1711   jint jresult = 0 ;
1712   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1713   ScicosID *arg2 = 0 ;
1714   kind_t arg3 ;
1715   object_properties_t arg4 ;
1716   int arg5 ;
1717   ScicosID temp2 ;
1718   update_status_t result;
1719   
1720   (void)jenv;
1721   (void)jcls;
1722   (void)jarg1_;
1723   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1724   temp2 = (ScicosID)jarg2; 
1725   arg2 = &temp2; 
1726   arg3 = (kind_t)jarg3; 
1727   arg4 = (object_properties_t)jarg4; 
1728   arg5 = (int)jarg5; 
1729   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< int >((ScicosID const &)*arg2,arg3,arg4,arg5);
1730   jresult = (jint)result; 
1731   return jresult;
1732 }
1733
1734
1735 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, jboolean jarg5) {
1736   jint jresult = 0 ;
1737   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1738   ScicosID *arg2 = 0 ;
1739   kind_t arg3 ;
1740   object_properties_t arg4 ;
1741   bool arg5 ;
1742   ScicosID temp2 ;
1743   update_status_t result;
1744   
1745   (void)jenv;
1746   (void)jcls;
1747   (void)jarg1_;
1748   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1749   temp2 = (ScicosID)jarg2; 
1750   arg2 = &temp2; 
1751   arg3 = (kind_t)jarg3; 
1752   arg4 = (object_properties_t)jarg4; 
1753   arg5 = jarg5 ? true : false; 
1754   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< bool >((ScicosID const &)*arg2,arg3,arg4,arg5);
1755   jresult = (jint)result; 
1756   return jresult;
1757 }
1758
1759
1760 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, jdouble jarg5) {
1761   jint jresult = 0 ;
1762   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1763   ScicosID *arg2 = 0 ;
1764   kind_t arg3 ;
1765   object_properties_t arg4 ;
1766   double arg5 ;
1767   ScicosID temp2 ;
1768   update_status_t result;
1769   
1770   (void)jenv;
1771   (void)jcls;
1772   (void)jarg1_;
1773   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1774   temp2 = (ScicosID)jarg2; 
1775   arg2 = &temp2; 
1776   arg3 = (kind_t)jarg3; 
1777   arg4 = (object_properties_t)jarg4; 
1778   arg5 = (double)jarg5; 
1779   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< double >((ScicosID const &)*arg2,arg3,arg4,arg5);
1780   jresult = (jint)result; 
1781   return jresult;
1782 }
1783
1784
1785 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, jstring jarg5) {
1786   jint jresult = 0 ;
1787   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1788   ScicosID *arg2 = 0 ;
1789   kind_t arg3 ;
1790   object_properties_t arg4 ;
1791   std::string arg5 ;
1792   ScicosID temp2 ;
1793   update_status_t result;
1794   
1795   (void)jenv;
1796   (void)jcls;
1797   (void)jarg1_;
1798   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1799   temp2 = (ScicosID)jarg2; 
1800   arg2 = &temp2; 
1801   arg3 = (kind_t)jarg3; 
1802   arg4 = (object_properties_t)jarg4; 
1803   if(!jarg5) {
1804     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
1805     return 0;
1806   } 
1807   const char *arg5_pstr = (const char *)jenv->GetStringUTFChars(jarg5, 0); 
1808   if (!arg5_pstr) return 0;
1809   (&arg5)->assign(arg5_pstr);
1810   jenv->ReleaseStringUTFChars(jarg5, arg5_pstr); 
1811   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::string >((ScicosID const &)*arg2,arg3,arg4,arg5);
1812   jresult = (jint)result; 
1813   return jresult;
1814 }
1815
1816
1817 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) {
1818   jint jresult = 0 ;
1819   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1820   ScicosID *arg2 = 0 ;
1821   kind_t arg3 ;
1822   object_properties_t arg4 ;
1823   long long arg5 ;
1824   ScicosID temp2 ;
1825   update_status_t result;
1826   
1827   (void)jenv;
1828   (void)jcls;
1829   (void)jarg1_;
1830   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1831   temp2 = (ScicosID)jarg2; 
1832   arg2 = &temp2; 
1833   arg3 = (kind_t)jarg3; 
1834   arg4 = (object_properties_t)jarg4; 
1835   arg5 = (long long)jarg5; 
1836   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< ScicosID >((ScicosID const &)*arg2,arg3,arg4,arg5);
1837   jresult = (jint)result; 
1838   return jresult;
1839 }
1840
1841
1842 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_) {
1843   jint jresult = 0 ;
1844   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1845   ScicosID *arg2 = 0 ;
1846   kind_t arg3 ;
1847   object_properties_t arg4 ;
1848   std::vector< int > arg5 ;
1849   ScicosID temp2 ;
1850   std::vector< int > *argp5 ;
1851   update_status_t result;
1852   
1853   (void)jenv;
1854   (void)jcls;
1855   (void)jarg1_;
1856   (void)jarg5_;
1857   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1858   temp2 = (ScicosID)jarg2; 
1859   arg2 = &temp2; 
1860   arg3 = (kind_t)jarg3; 
1861   arg4 = (object_properties_t)jarg4; 
1862   argp5 = *(std::vector< int > **)&jarg5; 
1863   if (!argp5) {
1864     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< int >");
1865     return 0;
1866   }
1867   arg5 = *argp5; 
1868   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::vector< int > >((ScicosID const &)*arg2,arg3,arg4,arg5);
1869   jresult = (jint)result; 
1870   return jresult;
1871 }
1872
1873
1874 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_) {
1875   jint jresult = 0 ;
1876   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1877   ScicosID *arg2 = 0 ;
1878   kind_t arg3 ;
1879   object_properties_t arg4 ;
1880   std::vector< bool > arg5 ;
1881   ScicosID temp2 ;
1882   std::vector< bool > *argp5 ;
1883   update_status_t result;
1884   
1885   (void)jenv;
1886   (void)jcls;
1887   (void)jarg1_;
1888   (void)jarg5_;
1889   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1890   temp2 = (ScicosID)jarg2; 
1891   arg2 = &temp2; 
1892   arg3 = (kind_t)jarg3; 
1893   arg4 = (object_properties_t)jarg4; 
1894   argp5 = *(std::vector< bool > **)&jarg5; 
1895   if (!argp5) {
1896     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< bool >");
1897     return 0;
1898   }
1899   arg5 = *argp5; 
1900   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::vector< bool > >((ScicosID const &)*arg2,arg3,arg4,arg5);
1901   jresult = (jint)result; 
1902   return jresult;
1903 }
1904
1905
1906 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_) {
1907   jint jresult = 0 ;
1908   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1909   ScicosID *arg2 = 0 ;
1910   kind_t arg3 ;
1911   object_properties_t arg4 ;
1912   std::vector< double > arg5 ;
1913   ScicosID temp2 ;
1914   std::vector< double > *argp5 ;
1915   update_status_t result;
1916   
1917   (void)jenv;
1918   (void)jcls;
1919   (void)jarg1_;
1920   (void)jarg5_;
1921   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1922   temp2 = (ScicosID)jarg2; 
1923   arg2 = &temp2; 
1924   arg3 = (kind_t)jarg3; 
1925   arg4 = (object_properties_t)jarg4; 
1926   argp5 = *(std::vector< double > **)&jarg5; 
1927   if (!argp5) {
1928     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< double >");
1929     return 0;
1930   }
1931   arg5 = *argp5; 
1932   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::vector< double > >((ScicosID const &)*arg2,arg3,arg4,arg5);
1933   jresult = (jint)result; 
1934   return jresult;
1935 }
1936
1937
1938 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_19(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1939   jint jresult = 0 ;
1940   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1941   ScicosID *arg2 = 0 ;
1942   kind_t arg3 ;
1943   object_properties_t arg4 ;
1944   std::vector< std::string > arg5 ;
1945   ScicosID temp2 ;
1946   std::vector< std::string > *argp5 ;
1947   update_status_t result;
1948   
1949   (void)jenv;
1950   (void)jcls;
1951   (void)jarg1_;
1952   (void)jarg5_;
1953   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1954   temp2 = (ScicosID)jarg2; 
1955   arg2 = &temp2; 
1956   arg3 = (kind_t)jarg3; 
1957   arg4 = (object_properties_t)jarg4; 
1958   argp5 = *(std::vector< std::string > **)&jarg5; 
1959   if (!argp5) {
1960     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< std::string >");
1961     return 0;
1962   }
1963   arg5 = *argp5; 
1964   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::vector< std::string > >((ScicosID const &)*arg2,arg3,arg4,arg5);
1965   jresult = (jint)result; 
1966   return jresult;
1967 }
1968
1969
1970 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_110(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1971   jint jresult = 0 ;
1972   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1973   ScicosID *arg2 = 0 ;
1974   kind_t arg3 ;
1975   object_properties_t arg4 ;
1976   std::vector< long long > arg5 ;
1977   ScicosID temp2 ;
1978   std::vector< long long > *argp5 ;
1979   update_status_t result;
1980   
1981   (void)jenv;
1982   (void)jcls;
1983   (void)jarg1_;
1984   (void)jarg5_;
1985   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1986   temp2 = (ScicosID)jarg2; 
1987   arg2 = &temp2; 
1988   arg3 = (kind_t)jarg3; 
1989   arg4 = (object_properties_t)jarg4; 
1990   argp5 = *(std::vector< long long > **)&jarg5; 
1991   if (!argp5) {
1992     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< long long >");
1993     return 0;
1994   }
1995   arg5 = *argp5; 
1996   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::vector< ScicosID > >((ScicosID const &)*arg2,arg3,arg4,arg5);
1997   jresult = (jint)result; 
1998   return jresult;
1999 }
2000
2001
2002 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfInt_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2003   jlong jresult = 0 ;
2004   std::vector< int > *result = 0 ;
2005   
2006   (void)jenv;
2007   (void)jcls;
2008   result = (std::vector< int > *)new std::vector< int >();
2009   *(std::vector< int > **)&jresult = result; 
2010   return jresult;
2011 }
2012
2013
2014 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfInt_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2015   jlong jresult = 0 ;
2016   std::vector< int >::size_type arg1 ;
2017   std::vector< int > *result = 0 ;
2018   
2019   (void)jenv;
2020   (void)jcls;
2021   arg1 = (std::vector< int >::size_type)jarg1; 
2022   result = (std::vector< int > *)new std::vector< int >(arg1);
2023   *(std::vector< int > **)&jresult = result; 
2024   return jresult;
2025 }
2026
2027
2028 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1ensureCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2029   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2030   std::vector< int >::size_type arg2 ;
2031   
2032   (void)jenv;
2033   (void)jcls;
2034   (void)jarg1_;
2035   arg1 = *(std::vector< int > **)&jarg1; 
2036   arg2 = (std::vector< int >::size_type)jarg2; 
2037   (arg1)->reserve(arg2);
2038 }
2039
2040
2041 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2042   jint jresult = 0 ;
2043   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2044   int result;
2045   
2046   (void)jenv;
2047   (void)jcls;
2048   (void)jarg1_;
2049   arg1 = *(std::vector< int > **)&jarg1; 
2050   result = (int)((std::vector< int > const *)arg1)->size();
2051   jresult = (jint)result; 
2052   return jresult;
2053 }
2054
2055
2056 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2057   jboolean jresult = 0 ;
2058   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2059   bool result;
2060   
2061   (void)jenv;
2062   (void)jcls;
2063   (void)jarg1_;
2064   arg1 = *(std::vector< int > **)&jarg1; 
2065   result = (bool)((std::vector< int > const *)arg1)->empty();
2066   jresult = (jboolean)result; 
2067   return jresult;
2068 }
2069
2070
2071 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2072   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2073   
2074   (void)jenv;
2075   (void)jcls;
2076   (void)jarg1_;
2077   arg1 = *(std::vector< int > **)&jarg1; 
2078   (arg1)->clear();
2079 }
2080
2081
2082 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1add_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2083   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2084   std::vector< int >::value_type *arg2 = 0 ;
2085   std::vector< int >::value_type temp2 ;
2086   
2087   (void)jenv;
2088   (void)jcls;
2089   (void)jarg1_;
2090   arg1 = *(std::vector< int > **)&jarg1; 
2091   temp2 = (std::vector< int >::value_type)jarg2; 
2092   arg2 = &temp2; 
2093   (arg1)->push_back((std::vector< int >::value_type const &)*arg2);
2094 }
2095
2096
2097 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1contains(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2098   jboolean jresult = 0 ;
2099   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2100   int *arg2 = 0 ;
2101   int temp2 ;
2102   bool result;
2103   
2104   (void)jenv;
2105   (void)jcls;
2106   (void)jarg1_;
2107   arg1 = *(std::vector< int > **)&jarg1; 
2108   temp2 = (int)jarg2; 
2109   arg2 = &temp2; 
2110   result = (bool)std_vector_Sl_int_Sg__contains(arg1,(int const &)*arg2);
2111   jresult = (jboolean)result; 
2112   return jresult;
2113 }
2114
2115
2116 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1indexOf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2117   jint jresult = 0 ;
2118   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2119   int *arg2 = 0 ;
2120   int temp2 ;
2121   int result;
2122   
2123   (void)jenv;
2124   (void)jcls;
2125   (void)jarg1_;
2126   arg1 = *(std::vector< int > **)&jarg1; 
2127   temp2 = (int)jarg2; 
2128   arg2 = &temp2; 
2129   result = (int)std_vector_Sl_int_Sg__indexOf(arg1,(int const &)*arg2);
2130   jresult = (jint)result; 
2131   return jresult;
2132 }
2133
2134
2135 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2136   jint jresult = 0 ;
2137   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2138   int arg2 ;
2139   std::vector< int >::value_type *result = 0 ;
2140   
2141   (void)jenv;
2142   (void)jcls;
2143   (void)jarg1_;
2144   arg1 = *(std::vector< int > **)&jarg1; 
2145   arg2 = (int)jarg2; 
2146   try {
2147     result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg__get(arg1,arg2);
2148   }
2149   catch(std::out_of_range &_e) {
2150     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2151     return 0;
2152   }
2153   
2154   jresult = (jint)*result; 
2155   return jresult;
2156 }
2157
2158
2159 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
2160   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2161   int arg2 ;
2162   std::vector< int >::value_type *arg3 = 0 ;
2163   std::vector< int >::value_type temp3 ;
2164   
2165   (void)jenv;
2166   (void)jcls;
2167   (void)jarg1_;
2168   arg1 = *(std::vector< int > **)&jarg1; 
2169   arg2 = (int)jarg2; 
2170   temp3 = (std::vector< int >::value_type)jarg3; 
2171   arg3 = &temp3; 
2172   try {
2173     std_vector_Sl_int_Sg__set(arg1,arg2,(int const &)*arg3);
2174   }
2175   catch(std::out_of_range &_e) {
2176     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2177     return ;
2178   }
2179   
2180 }
2181
2182
2183 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1add_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
2184   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2185   int arg2 ;
2186   std::vector< int >::value_type *arg3 = 0 ;
2187   std::vector< int >::value_type temp3 ;
2188   
2189   (void)jenv;
2190   (void)jcls;
2191   (void)jarg1_;
2192   arg1 = *(std::vector< int > **)&jarg1; 
2193   arg2 = (int)jarg2; 
2194   temp3 = (std::vector< int >::value_type)jarg3; 
2195   arg3 = &temp3; 
2196   try {
2197     std_vector_Sl_int_Sg__add__SWIG_1(arg1,arg2,(int const &)*arg3);
2198   }
2199   catch(std::out_of_range &_e) {
2200     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2201     return ;
2202   }
2203   
2204 }
2205
2206
2207 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2208   jboolean jresult = 0 ;
2209   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2210   std::vector< int >::value_type *arg2 = 0 ;
2211   std::vector< int >::value_type temp2 ;
2212   bool result;
2213   
2214   (void)jenv;
2215   (void)jcls;
2216   (void)jarg1_;
2217   arg1 = *(std::vector< int > **)&jarg1; 
2218   temp2 = (std::vector< int >::value_type)jarg2; 
2219   arg2 = &temp2; 
2220   result = (bool)std_vector_Sl_int_Sg__remove(arg1,(int const &)*arg2);
2221   jresult = (jboolean)result; 
2222   return jresult;
2223 }
2224
2225
2226 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfInt(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2227   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2228   
2229   (void)jenv;
2230   (void)jcls;
2231   arg1 = *(std::vector< int > **)&jarg1; 
2232   delete arg1;
2233 }
2234
2235
2236 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfBool_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2237   jlong jresult = 0 ;
2238   std::vector< bool > *result = 0 ;
2239   
2240   (void)jenv;
2241   (void)jcls;
2242   result = (std::vector< bool > *)new std::vector< bool >();
2243   *(std::vector< bool > **)&jresult = result; 
2244   return jresult;
2245 }
2246
2247
2248 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfBool_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2249   jlong jresult = 0 ;
2250   std::vector< bool >::size_type arg1 ;
2251   std::vector< bool > *result = 0 ;
2252   
2253   (void)jenv;
2254   (void)jcls;
2255   arg1 = (std::vector< bool >::size_type)jarg1; 
2256   result = (std::vector< bool > *)new std::vector< bool >(arg1);
2257   *(std::vector< bool > **)&jresult = result; 
2258   return jresult;
2259 }
2260
2261
2262 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2263   jlong jresult = 0 ;
2264   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2265   std::vector< bool >::size_type result;
2266   
2267   (void)jenv;
2268   (void)jcls;
2269   (void)jarg1_;
2270   arg1 = *(std::vector< bool > **)&jarg1; 
2271   result = ((std::vector< bool > const *)arg1)->size();
2272   jresult = (jlong)result; 
2273   return jresult;
2274 }
2275
2276
2277 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2278   jlong jresult = 0 ;
2279   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2280   std::vector< bool >::size_type result;
2281   
2282   (void)jenv;
2283   (void)jcls;
2284   (void)jarg1_;
2285   arg1 = *(std::vector< bool > **)&jarg1; 
2286   result = ((std::vector< bool > const *)arg1)->capacity();
2287   jresult = (jlong)result; 
2288   return jresult;
2289 }
2290
2291
2292 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1ensureCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2293   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2294   std::vector< bool >::size_type arg2 ;
2295   
2296   (void)jenv;
2297   (void)jcls;
2298   (void)jarg1_;
2299   arg1 = *(std::vector< bool > **)&jarg1; 
2300   arg2 = (std::vector< bool >::size_type)jarg2; 
2301   (arg1)->reserve(arg2);
2302 }
2303
2304
2305 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1resize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2306   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2307   std::vector< bool >::size_type arg2 ;
2308   
2309   (void)jenv;
2310   (void)jcls;
2311   (void)jarg1_;
2312   arg1 = *(std::vector< bool > **)&jarg1; 
2313   arg2 = (std::vector< bool >::size_type)jarg2; 
2314   (arg1)->resize(arg2);
2315 }
2316
2317
2318 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2319   jboolean jresult = 0 ;
2320   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2321   bool result;
2322   
2323   (void)jenv;
2324   (void)jcls;
2325   (void)jarg1_;
2326   arg1 = *(std::vector< bool > **)&jarg1; 
2327   result = (bool)((std::vector< bool > const *)arg1)->empty();
2328   jresult = (jboolean)result; 
2329   return jresult;
2330 }
2331
2332
2333 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2334   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2335   
2336   (void)jenv;
2337   (void)jcls;
2338   (void)jarg1_;
2339   arg1 = *(std::vector< bool > **)&jarg1; 
2340   (arg1)->clear();
2341 }
2342
2343
2344 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1add_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
2345   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2346   std::vector< bool >::value_type *arg2 = 0 ;
2347   std::vector< bool >::value_type temp2 ;
2348   
2349   (void)jenv;
2350   (void)jcls;
2351   (void)jarg1_;
2352   arg1 = *(std::vector< bool > **)&jarg1; 
2353   temp2 = jarg2 ? true : false; 
2354   arg2 = &temp2; 
2355   (arg1)->push_back((std::vector< bool >::value_type const &)*arg2);
2356 }
2357
2358
2359 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2360   jboolean jresult = 0 ;
2361   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2362   int arg2 ;
2363   bool result;
2364   
2365   (void)jenv;
2366   (void)jcls;
2367   (void)jarg1_;
2368   arg1 = *(std::vector< bool > **)&jarg1; 
2369   arg2 = (int)jarg2; 
2370   try {
2371     result = (bool)std_vector_Sl_bool_Sg__get(arg1,arg2);
2372   }
2373   catch(std::out_of_range &_e) {
2374     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2375     return 0;
2376   }
2377   
2378   jresult = (jboolean)result; 
2379   return jresult;
2380 }
2381
2382
2383 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) {
2384   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2385   int arg2 ;
2386   std::vector< bool >::value_type *arg3 = 0 ;
2387   std::vector< bool >::value_type temp3 ;
2388   
2389   (void)jenv;
2390   (void)jcls;
2391   (void)jarg1_;
2392   arg1 = *(std::vector< bool > **)&jarg1; 
2393   arg2 = (int)jarg2; 
2394   temp3 = jarg3 ? true : false; 
2395   arg3 = &temp3; 
2396   try {
2397     std_vector_Sl_bool_Sg__set(arg1,arg2,(bool const &)*arg3);
2398   }
2399   catch(std::out_of_range &_e) {
2400     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2401     return ;
2402   }
2403   
2404 }
2405
2406
2407 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1add_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) {
2408   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2409   int arg2 ;
2410   std::vector< bool >::value_type *arg3 = 0 ;
2411   std::vector< bool >::value_type temp3 ;
2412   
2413   (void)jenv;
2414   (void)jcls;
2415   (void)jarg1_;
2416   arg1 = *(std::vector< bool > **)&jarg1; 
2417   arg2 = (int)jarg2; 
2418   temp3 = jarg3 ? true : false; 
2419   arg3 = &temp3; 
2420   try {
2421     std_vector_Sl_bool_Sg__add__SWIG_1(arg1,arg2,(bool const &)*arg3);
2422   }
2423   catch(std::out_of_range &_e) {
2424     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2425     return ;
2426   }
2427   
2428 }
2429
2430
2431 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
2432   jboolean jresult = 0 ;
2433   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2434   std::vector< bool >::value_type *arg2 = 0 ;
2435   std::vector< bool >::value_type temp2 ;
2436   bool result;
2437   
2438   (void)jenv;
2439   (void)jcls;
2440   (void)jarg1_;
2441   arg1 = *(std::vector< bool > **)&jarg1; 
2442   temp2 = jarg2 ? true : false; 
2443   arg2 = &temp2; 
2444   result = (bool)std_vector_Sl_bool_Sg__remove(arg1,(bool const &)*arg2);
2445   jresult = (jboolean)result; 
2446   return jresult;
2447 }
2448
2449
2450 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfBool(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2451   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2452   
2453   (void)jenv;
2454   (void)jcls;
2455   arg1 = *(std::vector< bool > **)&jarg1; 
2456   delete arg1;
2457 }
2458
2459
2460 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfDouble_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2461   jlong jresult = 0 ;
2462   std::vector< double > *result = 0 ;
2463   
2464   (void)jenv;
2465   (void)jcls;
2466   result = (std::vector< double > *)new std::vector< double >();
2467   *(std::vector< double > **)&jresult = result; 
2468   return jresult;
2469 }
2470
2471
2472 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfDouble_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2473   jlong jresult = 0 ;
2474   std::vector< double >::size_type arg1 ;
2475   std::vector< double > *result = 0 ;
2476   
2477   (void)jenv;
2478   (void)jcls;
2479   arg1 = (std::vector< double >::size_type)jarg1; 
2480   result = (std::vector< double > *)new std::vector< double >(arg1);
2481   *(std::vector< double > **)&jresult = result; 
2482   return jresult;
2483 }
2484
2485
2486 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1ensureCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2487   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2488   std::vector< double >::size_type arg2 ;
2489   
2490   (void)jenv;
2491   (void)jcls;
2492   (void)jarg1_;
2493   arg1 = *(std::vector< double > **)&jarg1; 
2494   arg2 = (std::vector< double >::size_type)jarg2; 
2495   (arg1)->reserve(arg2);
2496 }
2497
2498
2499 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2500   jint jresult = 0 ;
2501   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2502   int result;
2503   
2504   (void)jenv;
2505   (void)jcls;
2506   (void)jarg1_;
2507   arg1 = *(std::vector< double > **)&jarg1; 
2508   result = (int)((std::vector< double > const *)arg1)->size();
2509   jresult = (jint)result; 
2510   return jresult;
2511 }
2512
2513
2514 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2515   jboolean jresult = 0 ;
2516   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2517   bool result;
2518   
2519   (void)jenv;
2520   (void)jcls;
2521   (void)jarg1_;
2522   arg1 = *(std::vector< double > **)&jarg1; 
2523   result = (bool)((std::vector< double > const *)arg1)->empty();
2524   jresult = (jboolean)result; 
2525   return jresult;
2526 }
2527
2528
2529 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2530   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2531   
2532   (void)jenv;
2533   (void)jcls;
2534   (void)jarg1_;
2535   arg1 = *(std::vector< double > **)&jarg1; 
2536   (arg1)->clear();
2537 }
2538
2539
2540 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1add_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
2541   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2542   std::vector< double >::value_type *arg2 = 0 ;
2543   std::vector< double >::value_type temp2 ;
2544   
2545   (void)jenv;
2546   (void)jcls;
2547   (void)jarg1_;
2548   arg1 = *(std::vector< double > **)&jarg1; 
2549   temp2 = (std::vector< double >::value_type)jarg2; 
2550   arg2 = &temp2; 
2551   (arg1)->push_back((std::vector< double >::value_type const &)*arg2);
2552 }
2553
2554
2555 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1contains(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
2556   jboolean jresult = 0 ;
2557   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2558   double *arg2 = 0 ;
2559   double temp2 ;
2560   bool result;
2561   
2562   (void)jenv;
2563   (void)jcls;
2564   (void)jarg1_;
2565   arg1 = *(std::vector< double > **)&jarg1; 
2566   temp2 = (double)jarg2; 
2567   arg2 = &temp2; 
2568   result = (bool)std_vector_Sl_double_Sg__contains(arg1,(double const &)*arg2);
2569   jresult = (jboolean)result; 
2570   return jresult;
2571 }
2572
2573
2574 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1indexOf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
2575   jint jresult = 0 ;
2576   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2577   double *arg2 = 0 ;
2578   double temp2 ;
2579   int result;
2580   
2581   (void)jenv;
2582   (void)jcls;
2583   (void)jarg1_;
2584   arg1 = *(std::vector< double > **)&jarg1; 
2585   temp2 = (double)jarg2; 
2586   arg2 = &temp2; 
2587   result = (int)std_vector_Sl_double_Sg__indexOf(arg1,(double const &)*arg2);
2588   jresult = (jint)result; 
2589   return jresult;
2590 }
2591
2592
2593 SWIGEXPORT jdouble JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2594   jdouble jresult = 0 ;
2595   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2596   int arg2 ;
2597   std::vector< double >::value_type *result = 0 ;
2598   
2599   (void)jenv;
2600   (void)jcls;
2601   (void)jarg1_;
2602   arg1 = *(std::vector< double > **)&jarg1; 
2603   arg2 = (int)jarg2; 
2604   try {
2605     result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg__get(arg1,arg2);
2606   }
2607   catch(std::out_of_range &_e) {
2608     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2609     return 0;
2610   }
2611   
2612   jresult = (jdouble)*result; 
2613   return jresult;
2614 }
2615
2616
2617 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jdouble jarg3) {
2618   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2619   int arg2 ;
2620   std::vector< double >::value_type *arg3 = 0 ;
2621   std::vector< double >::value_type temp3 ;
2622   
2623   (void)jenv;
2624   (void)jcls;
2625   (void)jarg1_;
2626   arg1 = *(std::vector< double > **)&jarg1; 
2627   arg2 = (int)jarg2; 
2628   temp3 = (std::vector< double >::value_type)jarg3; 
2629   arg3 = &temp3; 
2630   try {
2631     std_vector_Sl_double_Sg__set(arg1,arg2,(double const &)*arg3);
2632   }
2633   catch(std::out_of_range &_e) {
2634     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2635     return ;
2636   }
2637   
2638 }
2639
2640
2641 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1add_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jdouble jarg3) {
2642   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2643   int arg2 ;
2644   std::vector< double >::value_type *arg3 = 0 ;
2645   std::vector< double >::value_type temp3 ;
2646   
2647   (void)jenv;
2648   (void)jcls;
2649   (void)jarg1_;
2650   arg1 = *(std::vector< double > **)&jarg1; 
2651   arg2 = (int)jarg2; 
2652   temp3 = (std::vector< double >::value_type)jarg3; 
2653   arg3 = &temp3; 
2654   try {
2655     std_vector_Sl_double_Sg__add__SWIG_1(arg1,arg2,(double const &)*arg3);
2656   }
2657   catch(std::out_of_range &_e) {
2658     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2659     return ;
2660   }
2661   
2662 }
2663
2664
2665 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
2666   jboolean jresult = 0 ;
2667   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2668   std::vector< double >::value_type *arg2 = 0 ;
2669   std::vector< double >::value_type temp2 ;
2670   bool result;
2671   
2672   (void)jenv;
2673   (void)jcls;
2674   (void)jarg1_;
2675   arg1 = *(std::vector< double > **)&jarg1; 
2676   temp2 = (std::vector< double >::value_type)jarg2; 
2677   arg2 = &temp2; 
2678   result = (bool)std_vector_Sl_double_Sg__remove(arg1,(double const &)*arg2);
2679   jresult = (jboolean)result; 
2680   return jresult;
2681 }
2682
2683
2684 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfDouble(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2685   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2686   
2687   (void)jenv;
2688   (void)jcls;
2689   arg1 = *(std::vector< double > **)&jarg1; 
2690   delete arg1;
2691 }
2692
2693
2694 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfString_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2695   jlong jresult = 0 ;
2696   std::vector< std::string > *result = 0 ;
2697   
2698   (void)jenv;
2699   (void)jcls;
2700   result = (std::vector< std::string > *)new std::vector< std::string >();
2701   *(std::vector< std::string > **)&jresult = result; 
2702   return jresult;
2703 }
2704
2705
2706 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfString_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2707   jlong jresult = 0 ;
2708   std::vector< std::string >::size_type arg1 ;
2709   std::vector< std::string > *result = 0 ;
2710   
2711   (void)jenv;
2712   (void)jcls;
2713   arg1 = (std::vector< std::string >::size_type)jarg1; 
2714   result = (std::vector< std::string > *)new std::vector< std::string >(arg1);
2715   *(std::vector< std::string > **)&jresult = result; 
2716   return jresult;
2717 }
2718
2719
2720 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1ensureCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2721   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2722   std::vector< std::string >::size_type arg2 ;
2723   
2724   (void)jenv;
2725   (void)jcls;
2726   (void)jarg1_;
2727   arg1 = *(std::vector< std::string > **)&jarg1; 
2728   arg2 = (std::vector< std::string >::size_type)jarg2; 
2729   (arg1)->reserve(arg2);
2730 }
2731
2732
2733 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2734   jint jresult = 0 ;
2735   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2736   int result;
2737   
2738   (void)jenv;
2739   (void)jcls;
2740   (void)jarg1_;
2741   arg1 = *(std::vector< std::string > **)&jarg1; 
2742   result = (int)((std::vector< std::string > const *)arg1)->size();
2743   jresult = (jint)result; 
2744   return jresult;
2745 }
2746
2747
2748 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2749   jboolean jresult = 0 ;
2750   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2751   bool result;
2752   
2753   (void)jenv;
2754   (void)jcls;
2755   (void)jarg1_;
2756   arg1 = *(std::vector< std::string > **)&jarg1; 
2757   result = (bool)((std::vector< std::string > const *)arg1)->empty();
2758   jresult = (jboolean)result; 
2759   return jresult;
2760 }
2761
2762
2763 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2764   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2765   
2766   (void)jenv;
2767   (void)jcls;
2768   (void)jarg1_;
2769   arg1 = *(std::vector< std::string > **)&jarg1; 
2770   (arg1)->clear();
2771 }
2772
2773
2774 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1add_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
2775   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2776   std::vector< std::string >::value_type *arg2 = 0 ;
2777   
2778   (void)jenv;
2779   (void)jcls;
2780   (void)jarg1_;
2781   arg1 = *(std::vector< std::string > **)&jarg1; 
2782   if(!jarg2) {
2783     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
2784     return ;
2785   }
2786   const char *arg2_pstr = (const char *)jenv->GetStringUTFChars(jarg2, 0); 
2787   if (!arg2_pstr) return ;
2788   std::vector< std::string >::value_type arg2_str(arg2_pstr);
2789   arg2 = &arg2_str;
2790   jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
2791   (arg1)->push_back((std::vector< std::string >::value_type const &)*arg2);
2792 }
2793
2794
2795 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1contains(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
2796   jboolean jresult = 0 ;
2797   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2798   std::string *arg2 = 0 ;
2799   bool result;
2800   
2801   (void)jenv;
2802   (void)jcls;
2803   (void)jarg1_;
2804   arg1 = *(std::vector< std::string > **)&jarg1; 
2805   if(!jarg2) {
2806     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
2807     return 0;
2808   }
2809   const char *arg2_pstr = (const char *)jenv->GetStringUTFChars(jarg2, 0); 
2810   if (!arg2_pstr) return 0;
2811   std::string arg2_str(arg2_pstr);
2812   arg2 = &arg2_str;
2813   jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
2814   result = (bool)std_vector_Sl_std_string_Sg__contains(arg1,(std::string const &)*arg2);
2815   jresult = (jboolean)result; 
2816   return jresult;
2817 }
2818
2819
2820 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1indexOf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
2821   jint jresult = 0 ;
2822   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2823   std::string *arg2 = 0 ;
2824   int result;
2825   
2826   (void)jenv;
2827   (void)jcls;
2828   (void)jarg1_;
2829   arg1 = *(std::vector< std::string > **)&jarg1; 
2830   if(!jarg2) {
2831     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
2832     return 0;
2833   }
2834   const char *arg2_pstr = (const char *)jenv->GetStringUTFChars(jarg2, 0); 
2835   if (!arg2_pstr) return 0;
2836   std::string arg2_str(arg2_pstr);
2837   arg2 = &arg2_str;
2838   jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
2839   result = (int)std_vector_Sl_std_string_Sg__indexOf(arg1,(std::string const &)*arg2);
2840   jresult = (jint)result; 
2841   return jresult;
2842 }
2843
2844
2845 SWIGEXPORT jstring JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2846   jstring jresult = 0 ;
2847   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2848   int arg2 ;
2849   std::vector< std::string >::value_type *result = 0 ;
2850   
2851   (void)jenv;
2852   (void)jcls;
2853   (void)jarg1_;
2854   arg1 = *(std::vector< std::string > **)&jarg1; 
2855   arg2 = (int)jarg2; 
2856   try {
2857     result = (std::vector< std::string >::value_type *) &std_vector_Sl_std_string_Sg__get(arg1,arg2);
2858   }
2859   catch(std::out_of_range &_e) {
2860     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2861     return 0;
2862   }
2863   
2864   jresult = jenv->NewStringUTF(result->c_str()); 
2865   return jresult;
2866 }
2867
2868
2869 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) {
2870   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2871   int arg2 ;
2872   std::vector< std::string >::value_type *arg3 = 0 ;
2873   
2874   (void)jenv;
2875   (void)jcls;
2876   (void)jarg1_;
2877   arg1 = *(std::vector< std::string > **)&jarg1; 
2878   arg2 = (int)jarg2; 
2879   if(!jarg3) {
2880     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
2881     return ;
2882   }
2883   const char *arg3_pstr = (const char *)jenv->GetStringUTFChars(jarg3, 0); 
2884   if (!arg3_pstr) return ;
2885   std::vector< std::string >::value_type arg3_str(arg3_pstr);
2886   arg3 = &arg3_str;
2887   jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
2888   try {
2889     std_vector_Sl_std_string_Sg__set(arg1,arg2,(std::string const &)*arg3);
2890   }
2891   catch(std::out_of_range &_e) {
2892     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2893     return ;
2894   }
2895   
2896 }
2897
2898
2899 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1add_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) {
2900   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2901   int arg2 ;
2902   std::vector< std::string >::value_type *arg3 = 0 ;
2903   
2904   (void)jenv;
2905   (void)jcls;
2906   (void)jarg1_;
2907   arg1 = *(std::vector< std::string > **)&jarg1; 
2908   arg2 = (int)jarg2; 
2909   if(!jarg3) {
2910     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
2911     return ;
2912   }
2913   const char *arg3_pstr = (const char *)jenv->GetStringUTFChars(jarg3, 0); 
2914   if (!arg3_pstr) return ;
2915   std::vector< std::string >::value_type arg3_str(arg3_pstr);
2916   arg3 = &arg3_str;
2917   jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
2918   try {
2919     std_vector_Sl_std_string_Sg__add__SWIG_1(arg1,arg2,(std::string const &)*arg3);
2920   }
2921   catch(std::out_of_range &_e) {
2922     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2923     return ;
2924   }
2925   
2926 }
2927
2928
2929 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
2930   jboolean jresult = 0 ;
2931   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2932   std::vector< std::string >::value_type *arg2 = 0 ;
2933   bool result;
2934   
2935   (void)jenv;
2936   (void)jcls;
2937   (void)jarg1_;
2938   arg1 = *(std::vector< std::string > **)&jarg1; 
2939   if(!jarg2) {
2940     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
2941     return 0;
2942   }
2943   const char *arg2_pstr = (const char *)jenv->GetStringUTFChars(jarg2, 0); 
2944   if (!arg2_pstr) return 0;
2945   std::vector< std::string >::value_type arg2_str(arg2_pstr);
2946   arg2 = &arg2_str;
2947   jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
2948   result = (bool)std_vector_Sl_std_string_Sg__remove(arg1,(std::string const &)*arg2);
2949   jresult = (jboolean)result; 
2950   return jresult;
2951 }
2952
2953
2954 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfString(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2955   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2956   
2957   (void)jenv;
2958   (void)jcls;
2959   arg1 = *(std::vector< std::string > **)&jarg1; 
2960   delete arg1;
2961 }
2962
2963
2964 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfScicosID_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2965   jlong jresult = 0 ;
2966   std::vector< ScicosID > *result = 0 ;
2967   
2968   (void)jenv;
2969   (void)jcls;
2970   result = (std::vector< ScicosID > *)new std::vector< ScicosID >();
2971   *(std::vector< ScicosID > **)&jresult = result; 
2972   return jresult;
2973 }
2974
2975
2976 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfScicosID_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2977   jlong jresult = 0 ;
2978   std::vector< long long >::size_type arg1 ;
2979   std::vector< ScicosID > *result = 0 ;
2980   
2981   (void)jenv;
2982   (void)jcls;
2983   arg1 = (std::vector< long long >::size_type)jarg1; 
2984   result = (std::vector< ScicosID > *)new std::vector< ScicosID >(arg1);
2985   *(std::vector< ScicosID > **)&jresult = result; 
2986   return jresult;
2987 }
2988
2989
2990 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1ensureCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2991   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2992   std::vector< long long >::size_type arg2 ;
2993   
2994   (void)jenv;
2995   (void)jcls;
2996   (void)jarg1_;
2997   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2998   arg2 = (std::vector< long long >::size_type)jarg2; 
2999   (arg1)->reserve(arg2);
3000 }
3001
3002
3003 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3004   jint jresult = 0 ;
3005   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3006   int result;
3007   
3008   (void)jenv;
3009   (void)jcls;
3010   (void)jarg1_;
3011   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3012   result = (int)((std::vector< ScicosID > const *)arg1)->size();
3013   jresult = (jint)result; 
3014   return jresult;
3015 }
3016
3017
3018 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3019   jboolean jresult = 0 ;
3020   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3021   bool result;
3022   
3023   (void)jenv;
3024   (void)jcls;
3025   (void)jarg1_;
3026   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3027   result = (bool)((std::vector< ScicosID > const *)arg1)->empty();
3028   jresult = (jboolean)result; 
3029   return jresult;
3030 }
3031
3032
3033 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3034   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3035   
3036   (void)jenv;
3037   (void)jcls;
3038   (void)jarg1_;
3039   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3040   (arg1)->clear();
3041 }
3042
3043
3044 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1add_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
3045   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3046   std::vector< long long >::value_type *arg2 = 0 ;
3047   std::vector< long long >::value_type temp2 ;
3048   
3049   (void)jenv;
3050   (void)jcls;
3051   (void)jarg1_;
3052   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3053   temp2 = (std::vector< long long >::value_type)jarg2; 
3054   arg2 = &temp2; 
3055   (arg1)->push_back((std::vector< long long >::value_type const &)*arg2);
3056 }
3057
3058
3059 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1contains(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
3060   jboolean jresult = 0 ;
3061   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3062   long long *arg2 = 0 ;
3063   long long temp2 ;
3064   bool result;
3065   
3066   (void)jenv;
3067   (void)jcls;
3068   (void)jarg1_;
3069   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3070   temp2 = (long long)jarg2; 
3071   arg2 = &temp2; 
3072   result = (bool)std_vector_Sl_ScicosID_Sg__contains(arg1,(long long const &)*arg2);
3073   jresult = (jboolean)result; 
3074   return jresult;
3075 }
3076
3077
3078 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1indexOf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
3079   jint jresult = 0 ;
3080   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3081   long long *arg2 = 0 ;
3082   long long temp2 ;
3083   int result;
3084   
3085   (void)jenv;
3086   (void)jcls;
3087   (void)jarg1_;
3088   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3089   temp2 = (long long)jarg2; 
3090   arg2 = &temp2; 
3091   result = (int)std_vector_Sl_ScicosID_Sg__indexOf(arg1,(long long const &)*arg2);
3092   jresult = (jint)result; 
3093   return jresult;
3094 }
3095
3096
3097 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
3098   jlong jresult = 0 ;
3099   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3100   int arg2 ;
3101   std::vector< long long >::value_type *result = 0 ;
3102   
3103   (void)jenv;
3104   (void)jcls;
3105   (void)jarg1_;
3106   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3107   arg2 = (int)jarg2; 
3108   try {
3109     result = (std::vector< long long >::value_type *) &std_vector_Sl_ScicosID_Sg__get(arg1,arg2);
3110   }
3111   catch(std::out_of_range &_e) {
3112     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
3113     return 0;
3114   }
3115   
3116   jresult = (jlong)*result; 
3117   return jresult;
3118 }
3119
3120
3121 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
3122   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3123   int arg2 ;
3124   std::vector< long long >::value_type *arg3 = 0 ;
3125   std::vector< long long >::value_type temp3 ;
3126   
3127   (void)jenv;
3128   (void)jcls;
3129   (void)jarg1_;
3130   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3131   arg2 = (int)jarg2; 
3132   temp3 = (std::vector< long long >::value_type)jarg3; 
3133   arg3 = &temp3; 
3134   try {
3135     std_vector_Sl_ScicosID_Sg__set(arg1,arg2,(long long const &)*arg3);
3136   }
3137   catch(std::out_of_range &_e) {
3138     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
3139     return ;
3140   }
3141   
3142 }
3143
3144
3145 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1add_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
3146   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3147   int arg2 ;
3148   std::vector< long long >::value_type *arg3 = 0 ;
3149   std::vector< long long >::value_type temp3 ;
3150   
3151   (void)jenv;
3152   (void)jcls;
3153   (void)jarg1_;
3154   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3155   arg2 = (int)jarg2; 
3156   temp3 = (std::vector< long long >::value_type)jarg3; 
3157   arg3 = &temp3; 
3158   try {
3159     std_vector_Sl_ScicosID_Sg__add__SWIG_1(arg1,arg2,(long long const &)*arg3);
3160   }
3161   catch(std::out_of_range &_e) {
3162     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
3163     return ;
3164   }
3165   
3166 }
3167
3168
3169 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
3170   jboolean jresult = 0 ;
3171   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3172   std::vector< long long >::value_type *arg2 = 0 ;
3173   std::vector< long long >::value_type temp2 ;
3174   bool result;
3175   
3176   (void)jenv;
3177   (void)jcls;
3178   (void)jarg1_;
3179   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3180   temp2 = (std::vector< long long >::value_type)jarg2; 
3181   arg2 = &temp2; 
3182   result = (bool)std_vector_Sl_ScicosID_Sg__remove(arg1,(long long const &)*arg2);
3183   jresult = (jboolean)result; 
3184   return jresult;
3185 }
3186
3187
3188 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfScicosID(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3189   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3190   
3191   (void)jenv;
3192   (void)jcls;
3193   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3194   delete arg1;
3195 }
3196
3197
3198 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_register_1view(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_) {
3199   std::string *arg1 = 0 ;
3200   org_scilab_modules_scicos::View *arg2 = (org_scilab_modules_scicos::View *) 0 ;
3201   
3202   (void)jenv;
3203   (void)jcls;
3204   (void)jarg2_;
3205   if(!jarg1) {
3206     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
3207     return ;
3208   }
3209   const char *arg1_pstr = (const char *)jenv->GetStringUTFChars(jarg1, 0); 
3210   if (!arg1_pstr) return ;
3211   std::string arg1_str(arg1_pstr);
3212   arg1 = &arg1_str;
3213   jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
3214   arg2 = *(org_scilab_modules_scicos::View **)&jarg2; 
3215   register_view((std::string const &)*arg1,arg2);
3216 }
3217
3218
3219 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_unregister_1view(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3220   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
3221   
3222   (void)jenv;
3223   (void)jcls;
3224   (void)jarg1_;
3225   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
3226   unregister_view(arg1);
3227 }
3228
3229
3230 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_swig_1module_1init(JNIEnv *jenv, jclass jcls) {
3231   int i;
3232   
3233   static struct {
3234     const char *method;
3235     const char *signature;
3236   } methods[5] = {
3237     {
3238       "SwigDirector_View_objectCreated", "(Lorg/scilab/modules/xcos/View;JI)V" 
3239     },
3240     {
3241       "SwigDirector_View_objectReferenced", "(Lorg/scilab/modules/xcos/View;JIJ)V" 
3242     },
3243     {
3244       "SwigDirector_View_objectUnreferenced", "(Lorg/scilab/modules/xcos/View;JIJ)V" 
3245     },
3246     {
3247       "SwigDirector_View_objectDeleted", "(Lorg/scilab/modules/xcos/View;JI)V" 
3248     },
3249     {
3250       "SwigDirector_View_propertyUpdated", "(Lorg/scilab/modules/xcos/View;JIII)V" 
3251     }
3252   };
3253   Swig::jclass_JavaControllerJNI = (jclass) jenv->NewGlobalRef(jcls);
3254   if (!Swig::jclass_JavaControllerJNI) return;
3255   for (i = 0; i < (int) (sizeof(methods)/sizeof(methods[0])); ++i) {
3256     Swig::director_method_ids[i] = jenv->GetStaticMethodID(jcls, methods[i].method, methods[i].signature);
3257     if (!Swig::director_method_ids[i]) return;
3258   }
3259 }
3260
3261
3262 #ifdef __cplusplus
3263 }
3264 #endif
3265