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