Xcos: reintroduce a private xcosDiagramToScilab
[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 void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1resize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2042   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2043   std::vector< int >::size_type arg2 ;
2044   
2045   (void)jenv;
2046   (void)jcls;
2047   (void)jarg1_;
2048   arg1 = *(std::vector< int > **)&jarg1; 
2049   arg2 = (std::vector< int >::size_type)jarg2; 
2050   (arg1)->resize(arg2);
2051 }
2052
2053
2054 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2055   jint jresult = 0 ;
2056   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2057   int result;
2058   
2059   (void)jenv;
2060   (void)jcls;
2061   (void)jarg1_;
2062   arg1 = *(std::vector< int > **)&jarg1; 
2063   result = (int)((std::vector< int > const *)arg1)->size();
2064   jresult = (jint)result; 
2065   return jresult;
2066 }
2067
2068
2069 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2070   jboolean jresult = 0 ;
2071   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2072   bool result;
2073   
2074   (void)jenv;
2075   (void)jcls;
2076   (void)jarg1_;
2077   arg1 = *(std::vector< int > **)&jarg1; 
2078   result = (bool)((std::vector< int > const *)arg1)->empty();
2079   jresult = (jboolean)result; 
2080   return jresult;
2081 }
2082
2083
2084 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2085   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2086   
2087   (void)jenv;
2088   (void)jcls;
2089   (void)jarg1_;
2090   arg1 = *(std::vector< int > **)&jarg1; 
2091   (arg1)->clear();
2092 }
2093
2094
2095 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1add_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2096   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2097   std::vector< int >::value_type *arg2 = 0 ;
2098   std::vector< int >::value_type temp2 ;
2099   
2100   (void)jenv;
2101   (void)jcls;
2102   (void)jarg1_;
2103   arg1 = *(std::vector< int > **)&jarg1; 
2104   temp2 = (std::vector< int >::value_type)jarg2; 
2105   arg2 = &temp2; 
2106   (arg1)->push_back((std::vector< int >::value_type const &)*arg2);
2107 }
2108
2109
2110 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1contains(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2111   jboolean jresult = 0 ;
2112   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2113   int *arg2 = 0 ;
2114   int temp2 ;
2115   bool result;
2116   
2117   (void)jenv;
2118   (void)jcls;
2119   (void)jarg1_;
2120   arg1 = *(std::vector< int > **)&jarg1; 
2121   temp2 = (int)jarg2; 
2122   arg2 = &temp2; 
2123   result = (bool)std_vector_Sl_int_Sg__contains(arg1,(int const &)*arg2);
2124   jresult = (jboolean)result; 
2125   return jresult;
2126 }
2127
2128
2129 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1indexOf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2130   jint jresult = 0 ;
2131   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2132   int *arg2 = 0 ;
2133   int temp2 ;
2134   int result;
2135   
2136   (void)jenv;
2137   (void)jcls;
2138   (void)jarg1_;
2139   arg1 = *(std::vector< int > **)&jarg1; 
2140   temp2 = (int)jarg2; 
2141   arg2 = &temp2; 
2142   result = (int)std_vector_Sl_int_Sg__indexOf(arg1,(int const &)*arg2);
2143   jresult = (jint)result; 
2144   return jresult;
2145 }
2146
2147
2148 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2149   jint jresult = 0 ;
2150   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2151   int arg2 ;
2152   std::vector< int >::value_type *result = 0 ;
2153   
2154   (void)jenv;
2155   (void)jcls;
2156   (void)jarg1_;
2157   arg1 = *(std::vector< int > **)&jarg1; 
2158   arg2 = (int)jarg2; 
2159   try {
2160     result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg__get(arg1,arg2);
2161   }
2162   catch(std::out_of_range &_e) {
2163     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2164     return 0;
2165   }
2166   
2167   jresult = (jint)*result; 
2168   return jresult;
2169 }
2170
2171
2172 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
2173   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2174   int arg2 ;
2175   std::vector< int >::value_type *arg3 = 0 ;
2176   std::vector< int >::value_type temp3 ;
2177   
2178   (void)jenv;
2179   (void)jcls;
2180   (void)jarg1_;
2181   arg1 = *(std::vector< int > **)&jarg1; 
2182   arg2 = (int)jarg2; 
2183   temp3 = (std::vector< int >::value_type)jarg3; 
2184   arg3 = &temp3; 
2185   try {
2186     std_vector_Sl_int_Sg__set(arg1,arg2,(int const &)*arg3);
2187   }
2188   catch(std::out_of_range &_e) {
2189     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2190     return ;
2191   }
2192   
2193 }
2194
2195
2196 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) {
2197   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2198   int arg2 ;
2199   std::vector< int >::value_type *arg3 = 0 ;
2200   std::vector< int >::value_type temp3 ;
2201   
2202   (void)jenv;
2203   (void)jcls;
2204   (void)jarg1_;
2205   arg1 = *(std::vector< int > **)&jarg1; 
2206   arg2 = (int)jarg2; 
2207   temp3 = (std::vector< int >::value_type)jarg3; 
2208   arg3 = &temp3; 
2209   try {
2210     std_vector_Sl_int_Sg__add__SWIG_1(arg1,arg2,(int const &)*arg3);
2211   }
2212   catch(std::out_of_range &_e) {
2213     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2214     return ;
2215   }
2216   
2217 }
2218
2219
2220 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2221   jboolean jresult = 0 ;
2222   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2223   std::vector< int >::value_type *arg2 = 0 ;
2224   std::vector< int >::value_type temp2 ;
2225   bool result;
2226   
2227   (void)jenv;
2228   (void)jcls;
2229   (void)jarg1_;
2230   arg1 = *(std::vector< int > **)&jarg1; 
2231   temp2 = (std::vector< int >::value_type)jarg2; 
2232   arg2 = &temp2; 
2233   result = (bool)std_vector_Sl_int_Sg__remove(arg1,(int const &)*arg2);
2234   jresult = (jboolean)result; 
2235   return jresult;
2236 }
2237
2238
2239 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfInt(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2240   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2241   
2242   (void)jenv;
2243   (void)jcls;
2244   arg1 = *(std::vector< int > **)&jarg1; 
2245   delete arg1;
2246 }
2247
2248
2249 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfBool_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2250   jlong jresult = 0 ;
2251   std::vector< bool > *result = 0 ;
2252   
2253   (void)jenv;
2254   (void)jcls;
2255   result = (std::vector< bool > *)new std::vector< bool >();
2256   *(std::vector< bool > **)&jresult = result; 
2257   return jresult;
2258 }
2259
2260
2261 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfBool_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2262   jlong jresult = 0 ;
2263   std::vector< bool >::size_type arg1 ;
2264   std::vector< bool > *result = 0 ;
2265   
2266   (void)jenv;
2267   (void)jcls;
2268   arg1 = (std::vector< bool >::size_type)jarg1; 
2269   result = (std::vector< bool > *)new std::vector< bool >(arg1);
2270   *(std::vector< bool > **)&jresult = result; 
2271   return jresult;
2272 }
2273
2274
2275 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1ensureCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2276   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2277   std::vector< bool >::size_type arg2 ;
2278   
2279   (void)jenv;
2280   (void)jcls;
2281   (void)jarg1_;
2282   arg1 = *(std::vector< bool > **)&jarg1; 
2283   arg2 = (std::vector< bool >::size_type)jarg2; 
2284   (arg1)->reserve(arg2);
2285 }
2286
2287
2288 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1resize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2289   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2290   std::vector< bool >::size_type arg2 ;
2291   
2292   (void)jenv;
2293   (void)jcls;
2294   (void)jarg1_;
2295   arg1 = *(std::vector< bool > **)&jarg1; 
2296   arg2 = (std::vector< bool >::size_type)jarg2; 
2297   (arg1)->resize(arg2);
2298 }
2299
2300
2301 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2302   jint jresult = 0 ;
2303   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2304   int result;
2305   
2306   (void)jenv;
2307   (void)jcls;
2308   (void)jarg1_;
2309   arg1 = *(std::vector< bool > **)&jarg1; 
2310   result = (int)((std::vector< bool > const *)arg1)->size();
2311   jresult = (jint)result; 
2312   return jresult;
2313 }
2314
2315
2316 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2317   jboolean jresult = 0 ;
2318   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2319   bool result;
2320   
2321   (void)jenv;
2322   (void)jcls;
2323   (void)jarg1_;
2324   arg1 = *(std::vector< bool > **)&jarg1; 
2325   result = (bool)((std::vector< bool > const *)arg1)->empty();
2326   jresult = (jboolean)result; 
2327   return jresult;
2328 }
2329
2330
2331 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2332   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2333   
2334   (void)jenv;
2335   (void)jcls;
2336   (void)jarg1_;
2337   arg1 = *(std::vector< bool > **)&jarg1; 
2338   (arg1)->clear();
2339 }
2340
2341
2342 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1add_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
2343   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2344   std::vector< bool >::value_type *arg2 = 0 ;
2345   std::vector< bool >::value_type temp2 ;
2346   
2347   (void)jenv;
2348   (void)jcls;
2349   (void)jarg1_;
2350   arg1 = *(std::vector< bool > **)&jarg1; 
2351   temp2 = jarg2 ? true : false; 
2352   arg2 = &temp2; 
2353   (arg1)->push_back((std::vector< bool >::value_type const &)*arg2);
2354 }
2355
2356
2357 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2358   jboolean jresult = 0 ;
2359   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2360   int arg2 ;
2361   bool result;
2362   
2363   (void)jenv;
2364   (void)jcls;
2365   (void)jarg1_;
2366   arg1 = *(std::vector< bool > **)&jarg1; 
2367   arg2 = (int)jarg2; 
2368   try {
2369     result = (bool)std_vector_Sl_bool_Sg__get(arg1,arg2);
2370   }
2371   catch(std::out_of_range &_e) {
2372     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2373     return 0;
2374   }
2375   
2376   jresult = (jboolean)result; 
2377   return jresult;
2378 }
2379
2380
2381 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) {
2382   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2383   int arg2 ;
2384   std::vector< bool >::value_type *arg3 = 0 ;
2385   std::vector< bool >::value_type temp3 ;
2386   
2387   (void)jenv;
2388   (void)jcls;
2389   (void)jarg1_;
2390   arg1 = *(std::vector< bool > **)&jarg1; 
2391   arg2 = (int)jarg2; 
2392   temp3 = jarg3 ? true : false; 
2393   arg3 = &temp3; 
2394   try {
2395     std_vector_Sl_bool_Sg__set(arg1,arg2,(bool const &)*arg3);
2396   }
2397   catch(std::out_of_range &_e) {
2398     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2399     return ;
2400   }
2401   
2402 }
2403
2404
2405 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) {
2406   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2407   int arg2 ;
2408   std::vector< bool >::value_type *arg3 = 0 ;
2409   std::vector< bool >::value_type temp3 ;
2410   
2411   (void)jenv;
2412   (void)jcls;
2413   (void)jarg1_;
2414   arg1 = *(std::vector< bool > **)&jarg1; 
2415   arg2 = (int)jarg2; 
2416   temp3 = jarg3 ? true : false; 
2417   arg3 = &temp3; 
2418   try {
2419     std_vector_Sl_bool_Sg__add__SWIG_1(arg1,arg2,(bool const &)*arg3);
2420   }
2421   catch(std::out_of_range &_e) {
2422     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2423     return ;
2424   }
2425   
2426 }
2427
2428
2429 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
2430   jboolean jresult = 0 ;
2431   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2432   std::vector< bool >::value_type *arg2 = 0 ;
2433   std::vector< bool >::value_type temp2 ;
2434   bool result;
2435   
2436   (void)jenv;
2437   (void)jcls;
2438   (void)jarg1_;
2439   arg1 = *(std::vector< bool > **)&jarg1; 
2440   temp2 = jarg2 ? true : false; 
2441   arg2 = &temp2; 
2442   result = (bool)std_vector_Sl_bool_Sg__remove(arg1,(bool const &)*arg2);
2443   jresult = (jboolean)result; 
2444   return jresult;
2445 }
2446
2447
2448 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfBool(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2449   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2450   
2451   (void)jenv;
2452   (void)jcls;
2453   arg1 = *(std::vector< bool > **)&jarg1; 
2454   delete arg1;
2455 }
2456
2457
2458 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfDouble_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2459   jlong jresult = 0 ;
2460   std::vector< double > *result = 0 ;
2461   
2462   (void)jenv;
2463   (void)jcls;
2464   result = (std::vector< double > *)new std::vector< double >();
2465   *(std::vector< double > **)&jresult = result; 
2466   return jresult;
2467 }
2468
2469
2470 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfDouble_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2471   jlong jresult = 0 ;
2472   std::vector< double >::size_type arg1 ;
2473   std::vector< double > *result = 0 ;
2474   
2475   (void)jenv;
2476   (void)jcls;
2477   arg1 = (std::vector< double >::size_type)jarg1; 
2478   result = (std::vector< double > *)new std::vector< double >(arg1);
2479   *(std::vector< double > **)&jresult = result; 
2480   return jresult;
2481 }
2482
2483
2484 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1ensureCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2485   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2486   std::vector< double >::size_type arg2 ;
2487   
2488   (void)jenv;
2489   (void)jcls;
2490   (void)jarg1_;
2491   arg1 = *(std::vector< double > **)&jarg1; 
2492   arg2 = (std::vector< double >::size_type)jarg2; 
2493   (arg1)->reserve(arg2);
2494 }
2495
2496
2497 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1resize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2498   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2499   std::vector< double >::size_type arg2 ;
2500   
2501   (void)jenv;
2502   (void)jcls;
2503   (void)jarg1_;
2504   arg1 = *(std::vector< double > **)&jarg1; 
2505   arg2 = (std::vector< double >::size_type)jarg2; 
2506   (arg1)->resize(arg2);
2507 }
2508
2509
2510 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2511   jint jresult = 0 ;
2512   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2513   int result;
2514   
2515   (void)jenv;
2516   (void)jcls;
2517   (void)jarg1_;
2518   arg1 = *(std::vector< double > **)&jarg1; 
2519   result = (int)((std::vector< double > const *)arg1)->size();
2520   jresult = (jint)result; 
2521   return jresult;
2522 }
2523
2524
2525 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2526   jboolean jresult = 0 ;
2527   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2528   bool result;
2529   
2530   (void)jenv;
2531   (void)jcls;
2532   (void)jarg1_;
2533   arg1 = *(std::vector< double > **)&jarg1; 
2534   result = (bool)((std::vector< double > const *)arg1)->empty();
2535   jresult = (jboolean)result; 
2536   return jresult;
2537 }
2538
2539
2540 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2541   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2542   
2543   (void)jenv;
2544   (void)jcls;
2545   (void)jarg1_;
2546   arg1 = *(std::vector< double > **)&jarg1; 
2547   (arg1)->clear();
2548 }
2549
2550
2551 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1add_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
2552   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2553   std::vector< double >::value_type *arg2 = 0 ;
2554   std::vector< double >::value_type temp2 ;
2555   
2556   (void)jenv;
2557   (void)jcls;
2558   (void)jarg1_;
2559   arg1 = *(std::vector< double > **)&jarg1; 
2560   temp2 = (std::vector< double >::value_type)jarg2; 
2561   arg2 = &temp2; 
2562   (arg1)->push_back((std::vector< double >::value_type const &)*arg2);
2563 }
2564
2565
2566 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1contains(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
2567   jboolean jresult = 0 ;
2568   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2569   double *arg2 = 0 ;
2570   double temp2 ;
2571   bool result;
2572   
2573   (void)jenv;
2574   (void)jcls;
2575   (void)jarg1_;
2576   arg1 = *(std::vector< double > **)&jarg1; 
2577   temp2 = (double)jarg2; 
2578   arg2 = &temp2; 
2579   result = (bool)std_vector_Sl_double_Sg__contains(arg1,(double const &)*arg2);
2580   jresult = (jboolean)result; 
2581   return jresult;
2582 }
2583
2584
2585 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1indexOf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
2586   jint jresult = 0 ;
2587   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2588   double *arg2 = 0 ;
2589   double temp2 ;
2590   int result;
2591   
2592   (void)jenv;
2593   (void)jcls;
2594   (void)jarg1_;
2595   arg1 = *(std::vector< double > **)&jarg1; 
2596   temp2 = (double)jarg2; 
2597   arg2 = &temp2; 
2598   result = (int)std_vector_Sl_double_Sg__indexOf(arg1,(double const &)*arg2);
2599   jresult = (jint)result; 
2600   return jresult;
2601 }
2602
2603
2604 SWIGEXPORT jdouble JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2605   jdouble jresult = 0 ;
2606   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2607   int arg2 ;
2608   std::vector< double >::value_type *result = 0 ;
2609   
2610   (void)jenv;
2611   (void)jcls;
2612   (void)jarg1_;
2613   arg1 = *(std::vector< double > **)&jarg1; 
2614   arg2 = (int)jarg2; 
2615   try {
2616     result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg__get(arg1,arg2);
2617   }
2618   catch(std::out_of_range &_e) {
2619     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2620     return 0;
2621   }
2622   
2623   jresult = (jdouble)*result; 
2624   return jresult;
2625 }
2626
2627
2628 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jdouble jarg3) {
2629   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2630   int arg2 ;
2631   std::vector< double >::value_type *arg3 = 0 ;
2632   std::vector< double >::value_type temp3 ;
2633   
2634   (void)jenv;
2635   (void)jcls;
2636   (void)jarg1_;
2637   arg1 = *(std::vector< double > **)&jarg1; 
2638   arg2 = (int)jarg2; 
2639   temp3 = (std::vector< double >::value_type)jarg3; 
2640   arg3 = &temp3; 
2641   try {
2642     std_vector_Sl_double_Sg__set(arg1,arg2,(double const &)*arg3);
2643   }
2644   catch(std::out_of_range &_e) {
2645     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2646     return ;
2647   }
2648   
2649 }
2650
2651
2652 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) {
2653   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2654   int arg2 ;
2655   std::vector< double >::value_type *arg3 = 0 ;
2656   std::vector< double >::value_type temp3 ;
2657   
2658   (void)jenv;
2659   (void)jcls;
2660   (void)jarg1_;
2661   arg1 = *(std::vector< double > **)&jarg1; 
2662   arg2 = (int)jarg2; 
2663   temp3 = (std::vector< double >::value_type)jarg3; 
2664   arg3 = &temp3; 
2665   try {
2666     std_vector_Sl_double_Sg__add__SWIG_1(arg1,arg2,(double const &)*arg3);
2667   }
2668   catch(std::out_of_range &_e) {
2669     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2670     return ;
2671   }
2672   
2673 }
2674
2675
2676 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
2677   jboolean jresult = 0 ;
2678   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2679   std::vector< double >::value_type *arg2 = 0 ;
2680   std::vector< double >::value_type temp2 ;
2681   bool result;
2682   
2683   (void)jenv;
2684   (void)jcls;
2685   (void)jarg1_;
2686   arg1 = *(std::vector< double > **)&jarg1; 
2687   temp2 = (std::vector< double >::value_type)jarg2; 
2688   arg2 = &temp2; 
2689   result = (bool)std_vector_Sl_double_Sg__remove(arg1,(double const &)*arg2);
2690   jresult = (jboolean)result; 
2691   return jresult;
2692 }
2693
2694
2695 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfDouble(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2696   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2697   
2698   (void)jenv;
2699   (void)jcls;
2700   arg1 = *(std::vector< double > **)&jarg1; 
2701   delete arg1;
2702 }
2703
2704
2705 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfString_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2706   jlong jresult = 0 ;
2707   std::vector< std::string > *result = 0 ;
2708   
2709   (void)jenv;
2710   (void)jcls;
2711   result = (std::vector< std::string > *)new std::vector< std::string >();
2712   *(std::vector< std::string > **)&jresult = result; 
2713   return jresult;
2714 }
2715
2716
2717 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfString_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2718   jlong jresult = 0 ;
2719   std::vector< std::string >::size_type arg1 ;
2720   std::vector< std::string > *result = 0 ;
2721   
2722   (void)jenv;
2723   (void)jcls;
2724   arg1 = (std::vector< std::string >::size_type)jarg1; 
2725   result = (std::vector< std::string > *)new std::vector< std::string >(arg1);
2726   *(std::vector< std::string > **)&jresult = result; 
2727   return jresult;
2728 }
2729
2730
2731 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1ensureCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2732   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2733   std::vector< std::string >::size_type arg2 ;
2734   
2735   (void)jenv;
2736   (void)jcls;
2737   (void)jarg1_;
2738   arg1 = *(std::vector< std::string > **)&jarg1; 
2739   arg2 = (std::vector< std::string >::size_type)jarg2; 
2740   (arg1)->reserve(arg2);
2741 }
2742
2743
2744 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1resize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2745   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2746   std::vector< std::string >::size_type arg2 ;
2747   
2748   (void)jenv;
2749   (void)jcls;
2750   (void)jarg1_;
2751   arg1 = *(std::vector< std::string > **)&jarg1; 
2752   arg2 = (std::vector< std::string >::size_type)jarg2; 
2753   (arg1)->resize(arg2);
2754 }
2755
2756
2757 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2758   jint jresult = 0 ;
2759   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2760   int result;
2761   
2762   (void)jenv;
2763   (void)jcls;
2764   (void)jarg1_;
2765   arg1 = *(std::vector< std::string > **)&jarg1; 
2766   result = (int)((std::vector< std::string > const *)arg1)->size();
2767   jresult = (jint)result; 
2768   return jresult;
2769 }
2770
2771
2772 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2773   jboolean jresult = 0 ;
2774   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2775   bool result;
2776   
2777   (void)jenv;
2778   (void)jcls;
2779   (void)jarg1_;
2780   arg1 = *(std::vector< std::string > **)&jarg1; 
2781   result = (bool)((std::vector< std::string > const *)arg1)->empty();
2782   jresult = (jboolean)result; 
2783   return jresult;
2784 }
2785
2786
2787 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2788   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2789   
2790   (void)jenv;
2791   (void)jcls;
2792   (void)jarg1_;
2793   arg1 = *(std::vector< std::string > **)&jarg1; 
2794   (arg1)->clear();
2795 }
2796
2797
2798 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1add_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
2799   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2800   std::vector< std::string >::value_type *arg2 = 0 ;
2801   
2802   (void)jenv;
2803   (void)jcls;
2804   (void)jarg1_;
2805   arg1 = *(std::vector< std::string > **)&jarg1; 
2806   if(!jarg2) {
2807     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
2808     return ;
2809   }
2810   const char *arg2_pstr = (const char *)jenv->GetStringUTFChars(jarg2, 0); 
2811   if (!arg2_pstr) return ;
2812   std::vector< std::string >::value_type arg2_str(arg2_pstr);
2813   arg2 = &arg2_str;
2814   jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
2815   (arg1)->push_back((std::vector< std::string >::value_type const &)*arg2);
2816 }
2817
2818
2819 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1contains(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
2820   jboolean jresult = 0 ;
2821   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2822   std::string *arg2 = 0 ;
2823   bool result;
2824   
2825   (void)jenv;
2826   (void)jcls;
2827   (void)jarg1_;
2828   arg1 = *(std::vector< std::string > **)&jarg1; 
2829   if(!jarg2) {
2830     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
2831     return 0;
2832   }
2833   const char *arg2_pstr = (const char *)jenv->GetStringUTFChars(jarg2, 0); 
2834   if (!arg2_pstr) return 0;
2835   std::string arg2_str(arg2_pstr);
2836   arg2 = &arg2_str;
2837   jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
2838   result = (bool)std_vector_Sl_std_string_Sg__contains(arg1,(std::string const &)*arg2);
2839   jresult = (jboolean)result; 
2840   return jresult;
2841 }
2842
2843
2844 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1indexOf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
2845   jint jresult = 0 ;
2846   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2847   std::string *arg2 = 0 ;
2848   int result;
2849   
2850   (void)jenv;
2851   (void)jcls;
2852   (void)jarg1_;
2853   arg1 = *(std::vector< std::string > **)&jarg1; 
2854   if(!jarg2) {
2855     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
2856     return 0;
2857   }
2858   const char *arg2_pstr = (const char *)jenv->GetStringUTFChars(jarg2, 0); 
2859   if (!arg2_pstr) return 0;
2860   std::string arg2_str(arg2_pstr);
2861   arg2 = &arg2_str;
2862   jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
2863   result = (int)std_vector_Sl_std_string_Sg__indexOf(arg1,(std::string const &)*arg2);
2864   jresult = (jint)result; 
2865   return jresult;
2866 }
2867
2868
2869 SWIGEXPORT jstring JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2870   jstring jresult = 0 ;
2871   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2872   int arg2 ;
2873   std::vector< std::string >::value_type *result = 0 ;
2874   
2875   (void)jenv;
2876   (void)jcls;
2877   (void)jarg1_;
2878   arg1 = *(std::vector< std::string > **)&jarg1; 
2879   arg2 = (int)jarg2; 
2880   try {
2881     result = (std::vector< std::string >::value_type *) &std_vector_Sl_std_string_Sg__get(arg1,arg2);
2882   }
2883   catch(std::out_of_range &_e) {
2884     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2885     return 0;
2886   }
2887   
2888   jresult = jenv->NewStringUTF(result->c_str()); 
2889   return jresult;
2890 }
2891
2892
2893 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) {
2894   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2895   int arg2 ;
2896   std::vector< std::string >::value_type *arg3 = 0 ;
2897   
2898   (void)jenv;
2899   (void)jcls;
2900   (void)jarg1_;
2901   arg1 = *(std::vector< std::string > **)&jarg1; 
2902   arg2 = (int)jarg2; 
2903   if(!jarg3) {
2904     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
2905     return ;
2906   }
2907   const char *arg3_pstr = (const char *)jenv->GetStringUTFChars(jarg3, 0); 
2908   if (!arg3_pstr) return ;
2909   std::vector< std::string >::value_type arg3_str(arg3_pstr);
2910   arg3 = &arg3_str;
2911   jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
2912   try {
2913     std_vector_Sl_std_string_Sg__set(arg1,arg2,(std::string const &)*arg3);
2914   }
2915   catch(std::out_of_range &_e) {
2916     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2917     return ;
2918   }
2919   
2920 }
2921
2922
2923 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) {
2924   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2925   int arg2 ;
2926   std::vector< std::string >::value_type *arg3 = 0 ;
2927   
2928   (void)jenv;
2929   (void)jcls;
2930   (void)jarg1_;
2931   arg1 = *(std::vector< std::string > **)&jarg1; 
2932   arg2 = (int)jarg2; 
2933   if(!jarg3) {
2934     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
2935     return ;
2936   }
2937   const char *arg3_pstr = (const char *)jenv->GetStringUTFChars(jarg3, 0); 
2938   if (!arg3_pstr) return ;
2939   std::vector< std::string >::value_type arg3_str(arg3_pstr);
2940   arg3 = &arg3_str;
2941   jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
2942   try {
2943     std_vector_Sl_std_string_Sg__add__SWIG_1(arg1,arg2,(std::string const &)*arg3);
2944   }
2945   catch(std::out_of_range &_e) {
2946     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2947     return ;
2948   }
2949   
2950 }
2951
2952
2953 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
2954   jboolean jresult = 0 ;
2955   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2956   std::vector< std::string >::value_type *arg2 = 0 ;
2957   bool result;
2958   
2959   (void)jenv;
2960   (void)jcls;
2961   (void)jarg1_;
2962   arg1 = *(std::vector< std::string > **)&jarg1; 
2963   if(!jarg2) {
2964     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
2965     return 0;
2966   }
2967   const char *arg2_pstr = (const char *)jenv->GetStringUTFChars(jarg2, 0); 
2968   if (!arg2_pstr) return 0;
2969   std::vector< std::string >::value_type arg2_str(arg2_pstr);
2970   arg2 = &arg2_str;
2971   jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
2972   result = (bool)std_vector_Sl_std_string_Sg__remove(arg1,(std::string const &)*arg2);
2973   jresult = (jboolean)result; 
2974   return jresult;
2975 }
2976
2977
2978 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfString(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2979   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2980   
2981   (void)jenv;
2982   (void)jcls;
2983   arg1 = *(std::vector< std::string > **)&jarg1; 
2984   delete arg1;
2985 }
2986
2987
2988 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfScicosID_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2989   jlong jresult = 0 ;
2990   std::vector< ScicosID > *result = 0 ;
2991   
2992   (void)jenv;
2993   (void)jcls;
2994   result = (std::vector< ScicosID > *)new std::vector< ScicosID >();
2995   *(std::vector< ScicosID > **)&jresult = result; 
2996   return jresult;
2997 }
2998
2999
3000 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfScicosID_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3001   jlong jresult = 0 ;
3002   std::vector< long long >::size_type arg1 ;
3003   std::vector< ScicosID > *result = 0 ;
3004   
3005   (void)jenv;
3006   (void)jcls;
3007   arg1 = (std::vector< long long >::size_type)jarg1; 
3008   result = (std::vector< ScicosID > *)new std::vector< ScicosID >(arg1);
3009   *(std::vector< ScicosID > **)&jresult = result; 
3010   return jresult;
3011 }
3012
3013
3014 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1ensureCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
3015   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3016   std::vector< long long >::size_type arg2 ;
3017   
3018   (void)jenv;
3019   (void)jcls;
3020   (void)jarg1_;
3021   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3022   arg2 = (std::vector< long long >::size_type)jarg2; 
3023   (arg1)->reserve(arg2);
3024 }
3025
3026
3027 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1resize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
3028   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3029   std::vector< long long >::size_type arg2 ;
3030   
3031   (void)jenv;
3032   (void)jcls;
3033   (void)jarg1_;
3034   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3035   arg2 = (std::vector< long long >::size_type)jarg2; 
3036   (arg1)->resize(arg2);
3037 }
3038
3039
3040 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3041   jint jresult = 0 ;
3042   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3043   int result;
3044   
3045   (void)jenv;
3046   (void)jcls;
3047   (void)jarg1_;
3048   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3049   result = (int)((std::vector< ScicosID > const *)arg1)->size();
3050   jresult = (jint)result; 
3051   return jresult;
3052 }
3053
3054
3055 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3056   jboolean jresult = 0 ;
3057   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3058   bool result;
3059   
3060   (void)jenv;
3061   (void)jcls;
3062   (void)jarg1_;
3063   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3064   result = (bool)((std::vector< ScicosID > const *)arg1)->empty();
3065   jresult = (jboolean)result; 
3066   return jresult;
3067 }
3068
3069
3070 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3071   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3072   
3073   (void)jenv;
3074   (void)jcls;
3075   (void)jarg1_;
3076   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3077   (arg1)->clear();
3078 }
3079
3080
3081 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1add_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
3082   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3083   std::vector< long long >::value_type *arg2 = 0 ;
3084   std::vector< long long >::value_type temp2 ;
3085   
3086   (void)jenv;
3087   (void)jcls;
3088   (void)jarg1_;
3089   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3090   temp2 = (std::vector< long long >::value_type)jarg2; 
3091   arg2 = &temp2; 
3092   (arg1)->push_back((std::vector< long long >::value_type const &)*arg2);
3093 }
3094
3095
3096 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1contains(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
3097   jboolean jresult = 0 ;
3098   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3099   long long *arg2 = 0 ;
3100   long long temp2 ;
3101   bool result;
3102   
3103   (void)jenv;
3104   (void)jcls;
3105   (void)jarg1_;
3106   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3107   temp2 = (long long)jarg2; 
3108   arg2 = &temp2; 
3109   result = (bool)std_vector_Sl_ScicosID_Sg__contains(arg1,(long long const &)*arg2);
3110   jresult = (jboolean)result; 
3111   return jresult;
3112 }
3113
3114
3115 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1indexOf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
3116   jint jresult = 0 ;
3117   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3118   long long *arg2 = 0 ;
3119   long long temp2 ;
3120   int result;
3121   
3122   (void)jenv;
3123   (void)jcls;
3124   (void)jarg1_;
3125   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3126   temp2 = (long long)jarg2; 
3127   arg2 = &temp2; 
3128   result = (int)std_vector_Sl_ScicosID_Sg__indexOf(arg1,(long long const &)*arg2);
3129   jresult = (jint)result; 
3130   return jresult;
3131 }
3132
3133
3134 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
3135   jlong jresult = 0 ;
3136   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3137   int arg2 ;
3138   std::vector< long long >::value_type *result = 0 ;
3139   
3140   (void)jenv;
3141   (void)jcls;
3142   (void)jarg1_;
3143   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3144   arg2 = (int)jarg2; 
3145   try {
3146     result = (std::vector< long long >::value_type *) &std_vector_Sl_ScicosID_Sg__get(arg1,arg2);
3147   }
3148   catch(std::out_of_range &_e) {
3149     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
3150     return 0;
3151   }
3152   
3153   jresult = (jlong)*result; 
3154   return jresult;
3155 }
3156
3157
3158 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
3159   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3160   int arg2 ;
3161   std::vector< long long >::value_type *arg3 = 0 ;
3162   std::vector< long long >::value_type temp3 ;
3163   
3164   (void)jenv;
3165   (void)jcls;
3166   (void)jarg1_;
3167   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3168   arg2 = (int)jarg2; 
3169   temp3 = (std::vector< long long >::value_type)jarg3; 
3170   arg3 = &temp3; 
3171   try {
3172     std_vector_Sl_ScicosID_Sg__set(arg1,arg2,(long long const &)*arg3);
3173   }
3174   catch(std::out_of_range &_e) {
3175     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
3176     return ;
3177   }
3178   
3179 }
3180
3181
3182 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) {
3183   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3184   int arg2 ;
3185   std::vector< long long >::value_type *arg3 = 0 ;
3186   std::vector< long long >::value_type temp3 ;
3187   
3188   (void)jenv;
3189   (void)jcls;
3190   (void)jarg1_;
3191   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3192   arg2 = (int)jarg2; 
3193   temp3 = (std::vector< long long >::value_type)jarg3; 
3194   arg3 = &temp3; 
3195   try {
3196     std_vector_Sl_ScicosID_Sg__add__SWIG_1(arg1,arg2,(long long const &)*arg3);
3197   }
3198   catch(std::out_of_range &_e) {
3199     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
3200     return ;
3201   }
3202   
3203 }
3204
3205
3206 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
3207   jboolean jresult = 0 ;
3208   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3209   std::vector< long long >::value_type *arg2 = 0 ;
3210   std::vector< long long >::value_type temp2 ;
3211   bool result;
3212   
3213   (void)jenv;
3214   (void)jcls;
3215   (void)jarg1_;
3216   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3217   temp2 = (std::vector< long long >::value_type)jarg2; 
3218   arg2 = &temp2; 
3219   result = (bool)std_vector_Sl_ScicosID_Sg__remove(arg1,(long long const &)*arg2);
3220   jresult = (jboolean)result; 
3221   return jresult;
3222 }
3223
3224
3225 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfScicosID(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3226   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3227   
3228   (void)jenv;
3229   (void)jcls;
3230   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3231   delete arg1;
3232 }
3233
3234
3235 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_register_1view(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_) {
3236   std::string *arg1 = 0 ;
3237   org_scilab_modules_scicos::View *arg2 = (org_scilab_modules_scicos::View *) 0 ;
3238   
3239   (void)jenv;
3240   (void)jcls;
3241   (void)jarg2_;
3242   if(!jarg1) {
3243     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
3244     return ;
3245   }
3246   const char *arg1_pstr = (const char *)jenv->GetStringUTFChars(jarg1, 0); 
3247   if (!arg1_pstr) return ;
3248   std::string arg1_str(arg1_pstr);
3249   arg1 = &arg1_str;
3250   jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
3251   arg2 = *(org_scilab_modules_scicos::View **)&jarg2; 
3252   register_view((std::string const &)*arg1,arg2);
3253 }
3254
3255
3256 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_unregister_1view(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3257   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
3258   
3259   (void)jenv;
3260   (void)jcls;
3261   (void)jarg1_;
3262   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
3263   unregister_view(arg1);
3264 }
3265
3266
3267 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_swig_1module_1init(JNIEnv *jenv, jclass jcls) {
3268   int i;
3269   
3270   static struct {
3271     const char *method;
3272     const char *signature;
3273   } methods[5] = {
3274     {
3275       "SwigDirector_View_objectCreated", "(Lorg/scilab/modules/xcos/View;JI)V" 
3276     },
3277     {
3278       "SwigDirector_View_objectReferenced", "(Lorg/scilab/modules/xcos/View;JIJ)V" 
3279     },
3280     {
3281       "SwigDirector_View_objectUnreferenced", "(Lorg/scilab/modules/xcos/View;JIJ)V" 
3282     },
3283     {
3284       "SwigDirector_View_objectDeleted", "(Lorg/scilab/modules/xcos/View;JI)V" 
3285     },
3286     {
3287       "SwigDirector_View_propertyUpdated", "(Lorg/scilab/modules/xcos/View;JIII)V" 
3288     }
3289   };
3290   Swig::jclass_JavaControllerJNI = (jclass) jenv->NewGlobalRef(jcls);
3291   if (!Swig::jclass_JavaControllerJNI) return;
3292   for (i = 0; i < (int) (sizeof(methods)/sizeof(methods[0])); ++i) {
3293     Swig::director_method_ids[i] = jenv->GetStaticMethodID(jcls, methods[i].method, methods[i].signature);
3294     if (!Swig::director_method_ids[i]) return;
3295   }
3296 }
3297
3298
3299 #ifdef __cplusplus
3300 }
3301 #endif
3302