--- /dev/null
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 3.0.9
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+
+#ifndef SWIGCSHARP
+#define SWIGCSHARP
+#endif
+
+#define SWIG_DIRECTORS
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+ struct SwigMovePointer {
+ T *ptr;
+ SwigMovePointer(T *p) : ptr(p) { }
+ ~SwigMovePointer() { delete ptr; }
+ SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+ } pointer;
+ SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+ SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+ SwigValueWrapper() : pointer(0) { }
+ SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+ operator T&() const { return *pointer.ptr; }
+ T *operator&() { return pointer.ptr; }
+};
+
+template <typename T> T SwigValueInit() {
+ return T();
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * This section contains generic SWIG labels for method/variable
+ * declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+# define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+# define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+# define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+# define SWIGINLINE inline
+# else
+# define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+# define SWIGUNUSED __attribute__ ((__unused__))
+# else
+# define SWIGUNUSED
+# endif
+# elif defined(__ICC)
+# define SWIGUNUSED __attribute__ ((__unused__))
+# else
+# define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+# pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+# define SWIGUNUSEDPARM(p)
+# else
+# define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+# ifndef GCC_HASCLASSVISIBILITY
+# define GCC_HASCLASSVISIBILITY
+# endif
+# endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+# if defined(STATIC_LINKED)
+# define SWIGEXPORT
+# else
+# define SWIGEXPORT __declspec(dllexport)
+# endif
+# else
+# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+# define SWIGEXPORT __attribute__ ((visibility("default")))
+# else
+# define SWIGEXPORT
+# endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+# define SWIGSTDCALL __stdcall
+# else
+# define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used. So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+
+/* Support for throwing C# exceptions from C/C++. There are two types:
+ * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
+typedef enum {
+ SWIG_CSharpApplicationException,
+ SWIG_CSharpArithmeticException,
+ SWIG_CSharpDivideByZeroException,
+ SWIG_CSharpIndexOutOfRangeException,
+ SWIG_CSharpInvalidCastException,
+ SWIG_CSharpInvalidOperationException,
+ SWIG_CSharpIOException,
+ SWIG_CSharpNullReferenceException,
+ SWIG_CSharpOutOfMemoryException,
+ SWIG_CSharpOverflowException,
+ SWIG_CSharpSystemException
+} SWIG_CSharpExceptionCodes;
+
+typedef enum {
+ SWIG_CSharpArgumentException,
+ SWIG_CSharpArgumentNullException,
+ SWIG_CSharpArgumentOutOfRangeException
+} SWIG_CSharpExceptionArgumentCodes;
+
+typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
+typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
+
+typedef struct {
+ SWIG_CSharpExceptionCodes code;
+ SWIG_CSharpExceptionCallback_t callback;
+} SWIG_CSharpException_t;
+
+typedef struct {
+ SWIG_CSharpExceptionArgumentCodes code;
+ SWIG_CSharpExceptionArgumentCallback_t callback;
+} SWIG_CSharpExceptionArgument_t;
+
+static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
+ { SWIG_CSharpApplicationException, NULL },
+ { SWIG_CSharpArithmeticException, NULL },
+ { SWIG_CSharpDivideByZeroException, NULL },
+ { SWIG_CSharpIndexOutOfRangeException, NULL },
+ { SWIG_CSharpInvalidCastException, NULL },
+ { SWIG_CSharpInvalidOperationException, NULL },
+ { SWIG_CSharpIOException, NULL },
+ { SWIG_CSharpNullReferenceException, NULL },
+ { SWIG_CSharpOutOfMemoryException, NULL },
+ { SWIG_CSharpOverflowException, NULL },
+ { SWIG_CSharpSystemException, NULL }
+};
+
+static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
+ { SWIG_CSharpArgumentException, NULL },
+ { SWIG_CSharpArgumentNullException, NULL },
+ { SWIG_CSharpArgumentOutOfRangeException, NULL }
+};
+
+static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
+ SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
+ if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
+ callback = SWIG_csharp_exceptions[code].callback;
+ }
+ callback(msg);
+}
+
+static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
+ SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
+ if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
+ callback = SWIG_csharp_exceptions_argument[code].callback;
+ }
+ callback(msg, param_name);
+}
+
+
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
+ SWIG_CSharpExceptionCallback_t applicationCallback,
+ SWIG_CSharpExceptionCallback_t arithmeticCallback,
+ SWIG_CSharpExceptionCallback_t divideByZeroCallback,
+ SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
+ SWIG_CSharpExceptionCallback_t invalidCastCallback,
+ SWIG_CSharpExceptionCallback_t invalidOperationCallback,
+ SWIG_CSharpExceptionCallback_t ioCallback,
+ SWIG_CSharpExceptionCallback_t nullReferenceCallback,
+ SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
+ SWIG_CSharpExceptionCallback_t overflowCallback,
+ SWIG_CSharpExceptionCallback_t systemCallback) {
+ SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
+ SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
+ SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
+ SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
+ SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
+ SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
+ SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
+ SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
+ SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
+ SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
+ SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
+}
+
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
+ SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
+ SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
+ SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
+ SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
+ SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
+ SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
+}
+
+
+/* Callback for returning strings to C# without leaking memory */
+typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
+static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
+
+
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
+ SWIG_csharp_string_callback = callback;
+}
+
+
+/* Contract support */
+
+#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
+
+/* Errors in SWIG */
+#define SWIG_UnknownError -1
+#define SWIG_IOError -2
+#define SWIG_RuntimeError -3
+#define SWIG_IndexError -4
+#define SWIG_TypeError -5
+#define SWIG_DivisionByZero -6
+#define SWIG_OverflowError -7
+#define SWIG_SyntaxError -8
+#define SWIG_ValueError -9
+#define SWIG_SystemError -10
+#define SWIG_AttributeError -11
+#define SWIG_MemoryError -12
+#define SWIG_NullReferenceError -13
+
+
+
+/* -----------------------------------------------------------------------------
+ * director_common.swg
+ *
+ * This file contains support for director classes which is common between
+ * languages.
+ * ----------------------------------------------------------------------------- */
+
+/*
+ Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
+ 'Swig' namespace. This could be useful for multi-modules projects.
+*/
+#ifdef SWIG_DIRECTOR_STATIC
+/* Force anonymous (static) namespace */
+#define Swig
+#endif
+/* -----------------------------------------------------------------------------
+ * director.swg
+ *
+ * This file contains support for director classes so that C# proxy
+ * methods can be called from C++.
+ * ----------------------------------------------------------------------------- */
+
+#if defined(DEBUG_DIRECTOR_OWNED)
+#include <iostream>
+#endif
+#include <string>
+#include <exception>
+
+namespace Swig {
+ /* Director base class - not currently used in C# directors */
+ class Director {
+ };
+
+ /* Base class for director exceptions */
+ class DirectorException : public std::exception {
+ protected:
+ std::string swig_msg;
+
+ public:
+ DirectorException(const char *msg) : swig_msg(msg) {
+ }
+
+ DirectorException(const std::string &msg) : swig_msg(msg) {
+ }
+
+ virtual ~DirectorException() throw() {
+ }
+
+ const char *what() const throw() {
+ return swig_msg.c_str();
+ }
+ };
+
+ /* Pure virtual method exception */
+ class DirectorPureVirtualException : public DirectorException {
+ public:
+ DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
+ }
+ };
+}
+
+
+SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
+ if (code == SWIG_ValueError) {
+ SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
+ SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
+ } else {
+ SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
+ switch(code) {
+ case SWIG_MemoryError:
+ exception_code = SWIG_CSharpOutOfMemoryException;
+ break;
+ case SWIG_IndexError:
+ exception_code = SWIG_CSharpIndexOutOfRangeException;
+ break;
+ case SWIG_DivisionByZero:
+ exception_code = SWIG_CSharpDivideByZeroException;
+ break;
+ case SWIG_IOError:
+ exception_code = SWIG_CSharpIOException;
+ break;
+ case SWIG_OverflowError:
+ exception_code = SWIG_CSharpOverflowException;
+ break;
+ case SWIG_RuntimeError:
+ case SWIG_TypeError:
+ case SWIG_SyntaxError:
+ case SWIG_SystemError:
+ case SWIG_UnknownError:
+ default:
+ exception_code = SWIG_CSharpApplicationException;
+ break;
+ }
+ SWIG_CSharpSetPendingException(exception_code, msg);
+ }
+}
+
+
+#include <stdexcept>
+
+
+#define SWIGSTDCALL
+
+
+#include <dali/dali.h>
+#include <dali-toolkit/dali-toolkit.h>
+
+#include <dali/public-api/math/matrix.h>
+#include <dali/public-api/math/matrix3.h>
+#include <dali/public-api/math/viewport.h>
+#include <dali/public-api/object/property-key.h>
+
+#include <dali/public-api/adaptor-framework/timer.h>
+#include <dali/public-api/adaptor-framework/window.h>
+#include <dali/public-api/adaptor-framework/style-change.h>
+#include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
+
+#include <dali/devel-api/images/nine-patch-image.h>
+
+#include <dali-toolkit/devel-api/builder/builder.h>
+#include <dali-toolkit/devel-api/controls/popup/popup.h>
+#include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
+#include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
+#include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
+#include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
+#include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
+#include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
+
+#include <dali-toolkit/devel-api/visual-factory/visual-base.h>
+#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
+
+#include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
+
+// add here SWIG version check
+
+#if defined(_MSC_VER) // Microsoft Visual C++ 6.0
+// disable Swig-dependent warnings
+
+// 'identifier1' has C-linkage specified,
+// but returns UDT 'identifier2' which is incompatible with C
+#pragma warning(disable: 4190)
+
+// 'int' : forcing value to bool 'true' or 'false' (performance warning)
+#pragma warning(disable: 4800)
+
+// debug info too long etc etc
+#pragma warning(disable: 4786)
+#endif
+
+
+#include <stdexcept>
+
+
+#include <string>
+
+
+#include <vector>
+#include <algorithm>
+#include <stdexcept>
+
+
+#include <map>
+#include <algorithm>
+#include <stdexcept>
+
+
+#include <utility>
+
+
+typedef float floatp;
+
+SWIGINTERN floatp *new_floatp(){
+ return new float();
+}
+SWIGINTERN void delete_floatp(floatp *self){
+ if (self) delete self;
+}
+SWIGINTERN void floatp_assign(floatp *self,float value){
+ *self = value;
+}
+SWIGINTERN float floatp_value(floatp *self){
+ return *self;
+}
+SWIGINTERN float *floatp_cast(floatp *self){
+ return self;
+}
+SWIGINTERN floatp *floatp_frompointer(float *t){
+ return (floatp *) t;
+}
+
+typedef int intp;
+
+SWIGINTERN intp *new_intp(){
+ return new int();
+}
+SWIGINTERN void delete_intp(intp *self){
+ if (self) delete self;
+}
+SWIGINTERN void intp_assign(intp *self,int value){
+ *self = value;
+}
+SWIGINTERN int intp_value(intp *self){
+ return *self;
+}
+SWIGINTERN int *intp_cast(intp *self){
+ return self;
+}
+SWIGINTERN intp *intp_frompointer(int *t){
+ return (intp *) t;
+}
+
+typedef double doublep;
+
+SWIGINTERN doublep *new_doublep(){
+ return new double();
+}
+SWIGINTERN void delete_doublep(doublep *self){
+ if (self) delete self;
+}
+SWIGINTERN void doublep_assign(doublep *self,double value){
+ *self = value;
+}
+SWIGINTERN double doublep_value(doublep *self){
+ return *self;
+}
+SWIGINTERN double *doublep_cast(doublep *self){
+ return self;
+}
+SWIGINTERN doublep *doublep_frompointer(double *t){
+ return (doublep *) t;
+}
+
+typedef unsigned int uintp;
+
+SWIGINTERN uintp *new_uintp(){
+ return new unsigned int();
+}
+SWIGINTERN void delete_uintp(uintp *self){
+ if (self) delete self;
+}
+SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
+ *self = value;
+}
+SWIGINTERN unsigned int uintp_value(uintp *self){
+ return *self;
+}
+SWIGINTERN unsigned int *uintp_cast(uintp *self){
+ return self;
+}
+SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
+ return (uintp *) t;
+}
+
+typedef unsigned short ushortp;
+
+SWIGINTERN ushortp *new_ushortp(){
+ return new unsigned short();
+}
+SWIGINTERN void delete_ushortp(ushortp *self){
+ if (self) delete self;
+}
+SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
+ *self = value;
+}
+SWIGINTERN unsigned short ushortp_value(ushortp *self){
+ return *self;
+}
+SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
+ return self;
+}
+SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
+ return (ushortp *) t;
+}
+
+unsigned int int_to_uint(int x) {
+ return (unsigned int) x;
+}
+
+
+using namespace Dali;
+using namespace Dali::Toolkit;
+
+SWIGINTERN bool Dali_BaseHandle_IsHandleEmpty(Dali::BaseHandle const *self){
+ if( *self )
+ {
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
+ std::vector< Dali::TouchPoint >* pv = 0;
+ if (capacity >= 0) {
+ pv = new std::vector< Dali::TouchPoint >();
+ pv->reserve(capacity);
+ } else {
+ throw std::out_of_range("capacity");
+ }
+ return pv;
+ }
+SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
+ if (index>=0 && index<(int)self->size())
+ return (*self)[index];
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
+ if (index>=0 && index<(int)self->size())
+ return (*self)[index];
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
+ if (index>=0 && index<(int)self->size())
+ (*self)[index] = val;
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
+ self->insert(self->end(), values.begin(), values.end());
+ }
+SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
+ if (index < 0)
+ throw std::out_of_range("index");
+ if (count < 0)
+ throw std::out_of_range("count");
+ if (index >= (int)self->size()+1 || index+count > (int)self->size())
+ throw std::invalid_argument("invalid range");
+ return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
+ }
+SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
+ if (index>=0 && index<(int)self->size()+1)
+ self->insert(self->begin()+index, x);
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
+ if (index>=0 && index<(int)self->size()+1)
+ self->insert(self->begin()+index, values.begin(), values.end());
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
+ if (index>=0 && index<(int)self->size())
+ self->erase(self->begin() + index);
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
+ if (index < 0)
+ throw std::out_of_range("index");
+ if (count < 0)
+ throw std::out_of_range("count");
+ if (index >= (int)self->size()+1 || index+count > (int)self->size())
+ throw std::invalid_argument("invalid range");
+ self->erase(self->begin()+index, self->begin()+index+count);
+ }
+SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
+ if (count < 0)
+ throw std::out_of_range("count");
+ return new std::vector< Dali::TouchPoint >(count, value);
+ }
+SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
+ std::reverse(self->begin(), self->end());
+ }
+SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
+ if (index < 0)
+ throw std::out_of_range("index");
+ if (count < 0)
+ throw std::out_of_range("count");
+ if (index >= (int)self->size()+1 || index+count > (int)self->size())
+ throw std::invalid_argument("invalid range");
+ std::reverse(self->begin()+index, self->begin()+index+count);
+ }
+SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
+ if (index < 0)
+ throw std::out_of_range("index");
+ if (index+values.size() > self->size())
+ throw std::out_of_range("index");
+ std::copy(values.begin(), values.end(), self->begin()+index);
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg1, arg2 );
+ }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
+ self->Disconnect( func );
+ }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,Dali::Actor arg1,Dali::TouchData const &arg2){
+ return self->Emit( arg1, arg2 );
+ }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
+ self->Disconnect( func );
+ }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
+ return self->Emit( arg1, arg2 );
+ }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
+ self->Disconnect( func );
+ }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
+ return self->Emit( arg1, arg2 );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchData const &) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchData const &) > *self,Dali::TouchData const &arg){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg1, arg2 );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg1, arg2 );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg1, arg2 );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+ }
+
+ // keep argcs and argv so they're always available to DALi
+ int argC = 1;
+ char **argV = NULL;
+
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &arg){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &,void *) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::Application &,void *) > *self,Dali::Application &arg1,void *arg2){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg1, arg2 );
+ }
+SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
+ std::vector< unsigned int >* pv = 0;
+ if (capacity >= 0) {
+ pv = new std::vector< unsigned int >();
+ pv->reserve(capacity);
+ } else {
+ throw std::out_of_range("capacity");
+ }
+ return pv;
+ }
+SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
+ if (index>=0 && index<(int)self->size())
+ return (*self)[index];
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
+ if (index>=0 && index<(int)self->size())
+ return (*self)[index];
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
+ if (index>=0 && index<(int)self->size())
+ (*self)[index] = val;
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
+ self->insert(self->end(), values.begin(), values.end());
+ }
+SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
+ if (index < 0)
+ throw std::out_of_range("index");
+ if (count < 0)
+ throw std::out_of_range("count");
+ if (index >= (int)self->size()+1 || index+count > (int)self->size())
+ throw std::invalid_argument("invalid range");
+ return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
+ }
+SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
+ if (index>=0 && index<(int)self->size()+1)
+ self->insert(self->begin()+index, x);
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
+ if (index>=0 && index<(int)self->size()+1)
+ self->insert(self->begin()+index, values.begin(), values.end());
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
+ if (index>=0 && index<(int)self->size())
+ self->erase(self->begin() + index);
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
+ if (index < 0)
+ throw std::out_of_range("index");
+ if (count < 0)
+ throw std::out_of_range("count");
+ if (index >= (int)self->size()+1 || index+count > (int)self->size())
+ throw std::invalid_argument("invalid range");
+ self->erase(self->begin()+index, self->begin()+index+count);
+ }
+SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
+ if (count < 0)
+ throw std::out_of_range("count");
+ return new std::vector< unsigned int >(count, value);
+ }
+SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
+ std::reverse(self->begin(), self->end());
+ }
+SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
+ if (index < 0)
+ throw std::out_of_range("index");
+ if (count < 0)
+ throw std::out_of_range("count");
+ if (index >= (int)self->size()+1 || index+count > (int)self->size())
+ throw std::invalid_argument("invalid range");
+ std::reverse(self->begin()+index, self->begin()+index+count);
+ }
+SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
+ if (index < 0)
+ throw std::out_of_range("index");
+ if (index+values.size() > self->size())
+ throw std::out_of_range("index");
+ std::copy(values.begin(), values.end(), self->begin()+index);
+ }
+SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
+ return std::find(self->begin(), self->end(), value) != self->end();
+ }
+SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
+ int index = -1;
+ std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
+ if (it != self->end())
+ index = (int)(it - self->begin());
+ return index;
+ }
+SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
+ int index = -1;
+ std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
+ if (rit != self->rend())
+ index = (int)(self->rend() - 1 - rit);
+ return index;
+ }
+SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
+ std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
+ if (it != self->end()) {
+ self->erase(it);
+ return true;
+ }
+ return false;
+ }
+SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){
+ std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
+ if (capacity >= 0) {
+ pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
+ pv->reserve(capacity);
+ } else {
+ throw std::out_of_range("capacity");
+ }
+ return pv;
+ }
+SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
+ if (index>=0 && index<(int)self->size())
+ return (*self)[index];
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
+ if (index>=0 && index<(int)self->size())
+ return (*self)[index];
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
+ if (index>=0 && index<(int)self->size())
+ (*self)[index] = val;
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
+ self->insert(self->end(), values.begin(), values.end());
+ }
+SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
+ if (index < 0)
+ throw std::out_of_range("index");
+ if (count < 0)
+ throw std::out_of_range("count");
+ if (index >= (int)self->size()+1 || index+count > (int)self->size())
+ throw std::invalid_argument("invalid range");
+ return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
+ }
+SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){
+ if (index>=0 && index<(int)self->size()+1)
+ self->insert(self->begin()+index, x);
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
+ if (index>=0 && index<(int)self->size()+1)
+ self->insert(self->begin()+index, values.begin(), values.end());
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
+ if (index>=0 && index<(int)self->size())
+ self->erase(self->begin() + index);
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
+ if (index < 0)
+ throw std::out_of_range("index");
+ if (count < 0)
+ throw std::out_of_range("count");
+ if (index >= (int)self->size()+1 || index+count > (int)self->size())
+ throw std::invalid_argument("invalid range");
+ self->erase(self->begin()+index, self->begin()+index+count);
+ }
+SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){
+ if (count < 0)
+ throw std::out_of_range("count");
+ return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
+ }
+SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){
+ std::reverse(self->begin(), self->end());
+ }
+SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
+ if (index < 0)
+ throw std::out_of_range("index");
+ if (count < 0)
+ throw std::out_of_range("count");
+ if (index >= (int)self->size()+1 || index+count > (int)self->size())
+ throw std::invalid_argument("invalid range");
+ std::reverse(self->begin()+index, self->begin()+index+count);
+ }
+SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
+ if (index < 0)
+ throw std::out_of_range("index");
+ if (index+values.size() > self->size())
+ throw std::out_of_range("index");
+ std::copy(values.begin(), values.end(), self->begin()+index);
+ }
+SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
+ std::vector< Dali::Actor >* pv = 0;
+ if (capacity >= 0) {
+ pv = new std::vector< Dali::Actor >();
+ pv->reserve(capacity);
+ } else {
+ throw std::out_of_range("capacity");
+ }
+ return pv;
+ }
+SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
+ if (index>=0 && index<(int)self->size())
+ return (*self)[index];
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
+ if (index>=0 && index<(int)self->size())
+ return (*self)[index];
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
+ if (index>=0 && index<(int)self->size())
+ (*self)[index] = val;
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
+ self->insert(self->end(), values.begin(), values.end());
+ }
+SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
+ if (index < 0)
+ throw std::out_of_range("index");
+ if (count < 0)
+ throw std::out_of_range("count");
+ if (index >= (int)self->size()+1 || index+count > (int)self->size())
+ throw std::invalid_argument("invalid range");
+ return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
+ }
+SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
+ if (index>=0 && index<(int)self->size()+1)
+ self->insert(self->begin()+index, x);
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
+ if (index>=0 && index<(int)self->size()+1)
+ self->insert(self->begin()+index, values.begin(), values.end());
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
+ if (index>=0 && index<(int)self->size())
+ self->erase(self->begin() + index);
+ else
+ throw std::out_of_range("index");
+ }
+SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
+ if (index < 0)
+ throw std::out_of_range("index");
+ if (count < 0)
+ throw std::out_of_range("count");
+ if (index >= (int)self->size()+1 || index+count > (int)self->size())
+ throw std::invalid_argument("invalid range");
+ self->erase(self->begin()+index, self->begin()+index+count);
+ }
+SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
+ if (count < 0)
+ throw std::out_of_range("count");
+ return new std::vector< Dali::Actor >(count, value);
+ }
+SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
+ std::reverse(self->begin(), self->end());
+ }
+SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
+ if (index < 0)
+ throw std::out_of_range("index");
+ if (count < 0)
+ throw std::out_of_range("count");
+ if (index >= (int)self->size()+1 || index+count > (int)self->size())
+ throw std::invalid_argument("invalid range");
+ std::reverse(self->begin()+index, self->begin()+index+count);
+ }
+SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
+ if (index < 0)
+ throw std::out_of_range("index");
+ if (index+values.size() > self->size())
+ throw std::out_of_range("index");
+ std::copy(values.begin(), values.end(), self->begin()+index);
+ }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
+ self->Disconnect( func );
+ }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){
+ return self->Emit( arg );
+ }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &)){
+ self->Disconnect( func );
+ }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *self,Dali::Toolkit::AccessibilityManager &arg1,Dali::TouchEvent const &arg2){
+ return self->Emit( arg1, arg2 );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg1, arg2 );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg1, arg2 );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg1, arg2 );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg1, arg2 );
+ }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
+ self->Disconnect( func );
+ }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
+ return self->Emit( arg );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
+ return self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,Dali::Toolkit::TextEditor arg){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextField) > *self,Dali::Toolkit::TextField arg){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+ }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
+ self->Disconnect( func );
+ }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){
+ return self->Emit( arg1, arg2 );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+ }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
+ self->Disconnect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){
+ /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+ }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
+ self->Disconnect( func );
+ }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
+ return self->Emit( arg1, arg2 );
+ }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
+ return self->Empty();
+ }
+SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
+ return self->GetConnectionCount();
+ }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
+ self->Connect( func );
+ }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
+ self->Disconnect( func );
+ }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
+ return self->Emit( arg1, arg2 );
+ }
+
+
+/* ---------------------------------------------------
+ * C++ director class methods
+ * --------------------------------------------------- */
+
+#include "dali_wrap.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
+ void * jresult ;
+ floatp *result = 0 ;
+
+ {
+ try {
+ result = (floatp *)new_floatp();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
+ floatp *arg1 = (floatp *) 0 ;
+
+ arg1 = (floatp *)jarg1;
+ {
+ try {
+ delete_floatp(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
+ floatp *arg1 = (floatp *) 0 ;
+ float arg2 ;
+
+ arg1 = (floatp *)jarg1;
+ arg2 = (float)jarg2;
+ {
+ try {
+ floatp_assign(arg1,arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
+ float jresult ;
+ floatp *arg1 = (floatp *) 0 ;
+ float result;
+
+ arg1 = (floatp *)jarg1;
+ {
+ try {
+ result = (float)floatp_value(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
+ void * jresult ;
+ floatp *arg1 = (floatp *) 0 ;
+ float *result = 0 ;
+
+ arg1 = (floatp *)jarg1;
+ {
+ try {
+ result = (float *)floatp_cast(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
+ void * jresult ;
+ float *arg1 = (float *) 0 ;
+ floatp *result = 0 ;
+
+ arg1 = (float *)jarg1;
+ {
+ try {
+ result = (floatp *)floatp_frompointer(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
+ void * jresult ;
+ intp *result = 0 ;
+
+ {
+ try {
+ result = (intp *)new_intp();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
+ intp *arg1 = (intp *) 0 ;
+
+ arg1 = (intp *)jarg1;
+ {
+ try {
+ delete_intp(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
+ intp *arg1 = (intp *) 0 ;
+ int arg2 ;
+
+ arg1 = (intp *)jarg1;
+ arg2 = (int)jarg2;
+ {
+ try {
+ intp_assign(arg1,arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
+ int jresult ;
+ intp *arg1 = (intp *) 0 ;
+ int result;
+
+ arg1 = (intp *)jarg1;
+ {
+ try {
+ result = (int)intp_value(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
+ void * jresult ;
+ intp *arg1 = (intp *) 0 ;
+ int *result = 0 ;
+
+ arg1 = (intp *)jarg1;
+ {
+ try {
+ result = (int *)intp_cast(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
+ void * jresult ;
+ int *arg1 = (int *) 0 ;
+ intp *result = 0 ;
+
+ arg1 = (int *)jarg1;
+ {
+ try {
+ result = (intp *)intp_frompointer(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
+ void * jresult ;
+ doublep *result = 0 ;
+
+ {
+ try {
+ result = (doublep *)new_doublep();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
+ doublep *arg1 = (doublep *) 0 ;
+
+ arg1 = (doublep *)jarg1;
+ {
+ try {
+ delete_doublep(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
+ doublep *arg1 = (doublep *) 0 ;
+ double arg2 ;
+
+ arg1 = (doublep *)jarg1;
+ arg2 = (double)jarg2;
+ {
+ try {
+ doublep_assign(arg1,arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
+ double jresult ;
+ doublep *arg1 = (doublep *) 0 ;
+ double result;
+
+ arg1 = (doublep *)jarg1;
+ {
+ try {
+ result = (double)doublep_value(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
+ void * jresult ;
+ doublep *arg1 = (doublep *) 0 ;
+ double *result = 0 ;
+
+ arg1 = (doublep *)jarg1;
+ {
+ try {
+ result = (double *)doublep_cast(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
+ void * jresult ;
+ double *arg1 = (double *) 0 ;
+ doublep *result = 0 ;
+
+ arg1 = (double *)jarg1;
+ {
+ try {
+ result = (doublep *)doublep_frompointer(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
+ void * jresult ;
+ uintp *result = 0 ;
+
+ {
+ try {
+ result = (uintp *)new_uintp();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
+ uintp *arg1 = (uintp *) 0 ;
+
+ arg1 = (uintp *)jarg1;
+ {
+ try {
+ delete_uintp(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
+ uintp *arg1 = (uintp *) 0 ;
+ unsigned int arg2 ;
+
+ arg1 = (uintp *)jarg1;
+ arg2 = (unsigned int)jarg2;
+ {
+ try {
+ uintp_assign(arg1,arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
+ unsigned int jresult ;
+ uintp *arg1 = (uintp *) 0 ;
+ unsigned int result;
+
+ arg1 = (uintp *)jarg1;
+ {
+ try {
+ result = (unsigned int)uintp_value(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
+ void * jresult ;
+ uintp *arg1 = (uintp *) 0 ;
+ unsigned int *result = 0 ;
+
+ arg1 = (uintp *)jarg1;
+ {
+ try {
+ result = (unsigned int *)uintp_cast(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
+ void * jresult ;
+ unsigned int *arg1 = (unsigned int *) 0 ;
+ uintp *result = 0 ;
+
+ arg1 = (unsigned int *)jarg1;
+ {
+ try {
+ result = (uintp *)uintp_frompointer(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
+ void * jresult ;
+ ushortp *result = 0 ;
+
+ {
+ try {
+ result = (ushortp *)new_ushortp();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
+ ushortp *arg1 = (ushortp *) 0 ;
+
+ arg1 = (ushortp *)jarg1;
+ {
+ try {
+ delete_ushortp(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
+ ushortp *arg1 = (ushortp *) 0 ;
+ unsigned short arg2 ;
+
+ arg1 = (ushortp *)jarg1;
+ arg2 = (unsigned short)jarg2;
+ {
+ try {
+ ushortp_assign(arg1,arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
+ unsigned short jresult ;
+ ushortp *arg1 = (ushortp *) 0 ;
+ unsigned short result;
+
+ arg1 = (ushortp *)jarg1;
+ {
+ try {
+ result = (unsigned short)ushortp_value(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
+ void * jresult ;
+ ushortp *arg1 = (ushortp *) 0 ;
+ unsigned short *result = 0 ;
+
+ arg1 = (ushortp *)jarg1;
+ {
+ try {
+ result = (unsigned short *)ushortp_cast(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
+ void * jresult ;
+ unsigned short *arg1 = (unsigned short *) 0 ;
+ ushortp *result = 0 ;
+
+ arg1 = (unsigned short *)jarg1;
+ {
+ try {
+ result = (ushortp *)ushortp_frompointer(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
+ unsigned int jresult ;
+ int arg1 ;
+ unsigned int result;
+
+ arg1 = (int)jarg1;
+ {
+ try {
+ result = (unsigned int)int_to_uint(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
+ Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
+
+ arg1 = (Dali::RefObject *)jarg1;
+ {
+ try {
+ (arg1)->Reference();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
+ Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
+
+ arg1 = (Dali::RefObject *)jarg1;
+ {
+ try {
+ (arg1)->Unreference();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
+ int jresult ;
+ Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
+ int result;
+
+ arg1 = (Dali::RefObject *)jarg1;
+ {
+ try {
+ result = (int)(arg1)->ReferenceCount();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
+ void * jresult ;
+ Dali::Any *result = 0 ;
+
+ {
+ try {
+ result = (Dali::Any *)new Dali::Any();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
+ Dali::Any *arg1 = (Dali::Any *) 0 ;
+
+ arg1 = (Dali::Any *)jarg1;
+ {
+ try {
+ delete arg1;
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
+ char *arg1 = (char *) 0 ;
+
+ arg1 = (char *)jarg1;
+ {
+ try {
+ Dali::Any::AssertAlways((char const *)arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
+ void * jresult ;
+ Dali::Any *arg1 = 0 ;
+ Dali::Any *result = 0 ;
+
+ arg1 = (Dali::Any *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Any *arg1 = (Dali::Any *) 0 ;
+ Dali::Any *arg2 = 0 ;
+ Dali::Any *result = 0 ;
+
+ arg1 = (Dali::Any *)jarg1;
+ arg2 = (Dali::Any *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
+ void * jresult ;
+ Dali::Any *arg1 = (Dali::Any *) 0 ;
+ std::type_info *result = 0 ;
+
+ arg1 = (Dali::Any *)jarg1;
+ {
+ try {
+ result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
+ unsigned int jresult ;
+ Dali::Any *arg1 = (Dali::Any *) 0 ;
+ bool result;
+
+ arg1 = (Dali::Any *)jarg1;
+ {
+ try {
+ result = (bool)((Dali::Any const *)arg1)->Empty();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
+ void * jresult ;
+ std::type_info *arg1 = 0 ;
+ Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
+ Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
+ Dali::Any::AnyContainerBase *result = 0 ;
+
+ arg1 = (std::type_info *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
+ return 0;
+ }
+ arg2 = (Dali::Any::CloneFunc)jarg2;
+ arg3 = (Dali::Any::DeleteFunc)jarg3;
+ {
+ try {
+ result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
+ void * jresult ;
+ Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
+ std::type_info *result = 0 ;
+
+ arg1 = (Dali::Any::AnyContainerBase *)jarg1;
+ {
+ try {
+ result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
+ void * jresult ;
+ Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
+ ::std::type_info *result = 0 ;
+
+ arg1 = (Dali::Any::AnyContainerBase *)jarg1;
+ result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
+ Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
+ Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
+
+ arg1 = (Dali::Any::AnyContainerBase *)jarg1;
+ arg2 = (Dali::Any::CloneFunc)jarg2;
+ if (arg1) (arg1)->mCloneFunc = arg2;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
+ void * jresult ;
+ Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
+ Dali::Any::CloneFunc result;
+
+ arg1 = (Dali::Any::AnyContainerBase *)jarg1;
+ result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
+ Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
+ Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
+
+ arg1 = (Dali::Any::AnyContainerBase *)jarg1;
+ arg2 = (Dali::Any::DeleteFunc)jarg2;
+ if (arg1) (arg1)->mDeleteFunc = arg2;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
+ void * jresult ;
+ Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
+ Dali::Any::DeleteFunc result;
+
+ arg1 = (Dali::Any::AnyContainerBase *)jarg1;
+ result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
+ Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
+
+ arg1 = (Dali::Any::AnyContainerBase *)jarg1;
+ {
+ try {
+ delete arg1;
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
+ Dali::Any *arg1 = (Dali::Any *) 0 ;
+ Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
+
+ arg1 = (Dali::Any *)jarg1;
+ arg2 = (Dali::Any::AnyContainerBase *)jarg2;
+ if (arg1) (arg1)->mContainer = arg2;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
+ void * jresult ;
+ Dali::Any *arg1 = (Dali::Any *) 0 ;
+ Dali::Any::AnyContainerBase *result = 0 ;
+
+ arg1 = (Dali::Any *)jarg1;
+ result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
+ void * jresult ;
+ Dali::Vector2 *result = 0 ;
+
+ {
+ try {
+ result = (Dali::Vector2 *)new Dali::Vector2();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
+ void * jresult ;
+ float arg1 ;
+ float arg2 ;
+ Dali::Vector2 *result = 0 ;
+
+ arg1 = (float)jarg1;
+ arg2 = (float)jarg2;
+ {
+ try {
+ result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
+ void * jresult ;
+ float *arg1 = (float *) 0 ;
+ Dali::Vector2 *result = 0 ;
+
+ arg1 = jarg1;
+ {
+ try {
+ result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+
+
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = 0 ;
+ Dali::Vector2 *result = 0 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = 0 ;
+ Dali::Vector2 *result = 0 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
+ void * jresult ;
+ Dali::Vector2 *result = 0 ;
+
+ result = (Dali::Vector2 *)&Dali::Vector2::ONE;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
+ void * jresult ;
+ Dali::Vector2 *result = 0 ;
+
+ result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
+ void * jresult ;
+ Dali::Vector2 *result = 0 ;
+
+ result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
+ void * jresult ;
+ Dali::Vector2 *result = 0 ;
+
+ result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
+ void * jresult ;
+ Dali::Vector2 *result = 0 ;
+
+ result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
+ void * jresult ;
+ Dali::Vector2 *result = 0 ;
+
+ result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
+ void * jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ float *arg2 = (float *) 0 ;
+ Dali::Vector2 *result = 0 ;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ arg2 = jarg2;
+ {
+ try {
+ result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+
+
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ Dali::Vector3 *arg2 = 0 ;
+ Dali::Vector2 *result = 0 ;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ arg2 = (Dali::Vector3 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ Dali::Vector4 *arg2 = 0 ;
+ Dali::Vector2 *result = 0 ;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ arg2 = (Dali::Vector4 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ Dali::Vector2 *arg2 = 0 ;
+ Dali::Vector2 result;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ arg2 = (Dali::Vector2 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector2((const Dali::Vector2 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ Dali::Vector2 *arg2 = 0 ;
+ Dali::Vector2 *result = 0 ;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ arg2 = (Dali::Vector2 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ Dali::Vector2 *arg2 = 0 ;
+ Dali::Vector2 result;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ arg2 = (Dali::Vector2 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector2((const Dali::Vector2 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ Dali::Vector2 *arg2 = 0 ;
+ Dali::Vector2 *result = 0 ;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ arg2 = (Dali::Vector2 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ Dali::Vector2 *arg2 = 0 ;
+ Dali::Vector2 result;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ arg2 = (Dali::Vector2 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector2((const Dali::Vector2 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
+ void * jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ float arg2 ;
+ Dali::Vector2 result;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ arg2 = (float)jarg2;
+ {
+ try {
+ result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector2((const Dali::Vector2 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ Dali::Vector2 *arg2 = 0 ;
+ Dali::Vector2 *result = 0 ;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ arg2 = (Dali::Vector2 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
+ void * jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ float arg2 ;
+ Dali::Vector2 *result = 0 ;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ arg2 = (float)jarg2;
+ {
+ try {
+ result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ Dali::Vector2 *arg2 = 0 ;
+ Dali::Vector2 result;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ arg2 = (Dali::Vector2 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector2((const Dali::Vector2 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
+ void * jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ float arg2 ;
+ Dali::Vector2 result;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ arg2 = (float)jarg2;
+ {
+ try {
+ result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector2((const Dali::Vector2 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ Dali::Vector2 *arg2 = 0 ;
+ Dali::Vector2 *result = 0 ;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ arg2 = (Dali::Vector2 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
+ void * jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ float arg2 ;
+ Dali::Vector2 *result = 0 ;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ arg2 = (float)jarg2;
+ {
+ try {
+ result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
+ void * jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ Dali::Vector2 result;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ {
+ try {
+ result = ((Dali::Vector2 const *)arg1)->operator -();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector2((const Dali::Vector2 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ Dali::Vector2 *arg2 = 0 ;
+ bool result;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ arg2 = (Dali::Vector2 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ Dali::Vector2 *arg2 = 0 ;
+ bool result;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ arg2 = (Dali::Vector2 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
+ float jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ unsigned int arg2 ;
+ float *result = 0 ;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ arg2 = (unsigned int)jarg2;
+ {
+ try {
+ result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = *result;
+ return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
+ float jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ {
+ try {
+ result = (float)((Dali::Vector2 const *)arg1)->Length();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
+ float jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ {
+ try {
+ result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ {
+ try {
+ (arg1)->Normalize();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ Dali::Vector2 *arg2 = 0 ;
+ Dali::Vector2 *arg3 = 0 ;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ arg2 = (Dali::Vector2 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+ return ;
+ }
+ arg3 = (Dali::Vector2 *)jarg3;
+ if (!arg3) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+ return ;
+ }
+ {
+ try {
+ (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
+ void * jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ float *result = 0 ;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ {
+ try {
+ result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_x_set(void * jarg1, float jarg2) {
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->x = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_x_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ result = (float) ((arg1)->x);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_width_set(void * jarg1, float jarg2) {
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->width = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_width_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ result = (float) ((arg1)->width);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_y_set(void * jarg1, float jarg2) {
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->y = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_y_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ result = (float) ((arg1)->y);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_height_set(void * jarg1, float jarg2) {
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->height = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_height_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ result = (float) ((arg1)->height);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
+ Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ {
+ try {
+ delete arg1;
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector2 *arg1 = 0 ;
+ Dali::Vector2 *arg2 = 0 ;
+ Dali::Vector2 result;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+ return 0;
+ }
+ arg2 = (Dali::Vector2 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector2((const Dali::Vector2 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector2 *arg1 = 0 ;
+ Dali::Vector2 *arg2 = 0 ;
+ Dali::Vector2 result;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+ return 0;
+ }
+ arg2 = (Dali::Vector2 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector2((const Dali::Vector2 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
+ void * jresult ;
+ Dali::Vector2 *arg1 = 0 ;
+ float *arg2 = 0 ;
+ float *arg3 = 0 ;
+ float temp2 ;
+ float temp3 ;
+ Dali::Vector2 result;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+ return 0;
+ }
+ temp2 = (float)jarg2;
+ arg2 = &temp2;
+ temp3 = (float)jarg3;
+ arg3 = &temp3;
+ {
+ try {
+ result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector2((const Dali::Vector2 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
+ void * jresult ;
+ Dali::Vector3 *result = 0 ;
+
+ {
+ try {
+ result = (Dali::Vector3 *)new Dali::Vector3();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
+ void * jresult ;
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ Dali::Vector3 *result = 0 ;
+
+ arg1 = (float)jarg1;
+ arg2 = (float)jarg2;
+ arg3 = (float)jarg3;
+ {
+ try {
+ result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
+ void * jresult ;
+ float *arg1 = (float *) 0 ;
+ Dali::Vector3 *result = 0 ;
+
+ arg1 = jarg1;
+ {
+ try {
+ result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+
+
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
+ void * jresult ;
+ Dali::Vector2 *arg1 = 0 ;
+ Dali::Vector3 *result = 0 ;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = 0 ;
+ Dali::Vector3 *result = 0 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
+ void * jresult ;
+ Dali::Vector3 *result = 0 ;
+
+ result = (Dali::Vector3 *)&Dali::Vector3::ONE;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
+ void * jresult ;
+ Dali::Vector3 *result = 0 ;
+
+ result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
+ void * jresult ;
+ Dali::Vector3 *result = 0 ;
+
+ result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
+ void * jresult ;
+ Dali::Vector3 *result = 0 ;
+
+ result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
+ void * jresult ;
+ Dali::Vector3 *result = 0 ;
+
+ result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
+ void * jresult ;
+ Dali::Vector3 *result = 0 ;
+
+ result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
+ void * jresult ;
+ Dali::Vector3 *result = 0 ;
+
+ result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
+ void * jresult ;
+ Dali::Vector3 *result = 0 ;
+
+ result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float *arg2 = (float *) 0 ;
+ Dali::Vector3 *result = 0 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = jarg2;
+ {
+ try {
+ result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+
+
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ Dali::Vector2 *arg2 = 0 ;
+ Dali::Vector3 *result = 0 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (Dali::Vector2 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ Dali::Vector4 *arg2 = 0 ;
+ Dali::Vector3 *result = 0 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (Dali::Vector4 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ Dali::Vector3 *arg2 = 0 ;
+ Dali::Vector3 result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (Dali::Vector3 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector3((const Dali::Vector3 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ Dali::Vector3 *arg2 = 0 ;
+ Dali::Vector3 *result = 0 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (Dali::Vector3 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ Dali::Vector3 *arg2 = 0 ;
+ Dali::Vector3 result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (Dali::Vector3 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector3((const Dali::Vector3 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ Dali::Vector3 *arg2 = 0 ;
+ Dali::Vector3 *result = 0 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (Dali::Vector3 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ Dali::Vector3 *arg2 = 0 ;
+ Dali::Vector3 result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (Dali::Vector3 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector3((const Dali::Vector3 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float arg2 ;
+ Dali::Vector3 result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (float)jarg2;
+ {
+ try {
+ result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector3((const Dali::Vector3 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ Dali::Vector3 *arg2 = 0 ;
+ Dali::Vector3 *result = 0 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (Dali::Vector3 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float arg2 ;
+ Dali::Vector3 *result = 0 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (float)jarg2;
+ {
+ try {
+ result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ Dali::Quaternion *arg2 = 0 ;
+ Dali::Vector3 *result = 0 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (Dali::Quaternion *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ Dali::Vector3 *arg2 = 0 ;
+ Dali::Vector3 result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (Dali::Vector3 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector3((const Dali::Vector3 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float arg2 ;
+ Dali::Vector3 result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (float)jarg2;
+ {
+ try {
+ result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector3((const Dali::Vector3 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ Dali::Vector3 *arg2 = 0 ;
+ Dali::Vector3 *result = 0 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (Dali::Vector3 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float arg2 ;
+ Dali::Vector3 *result = 0 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (float)jarg2;
+ {
+ try {
+ result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ Dali::Vector3 result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ {
+ try {
+ result = ((Dali::Vector3 const *)arg1)->operator -();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector3((const Dali::Vector3 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ Dali::Vector3 *arg2 = 0 ;
+ bool result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (Dali::Vector3 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ Dali::Vector3 *arg2 = 0 ;
+ bool result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (Dali::Vector3 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
+ float jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ unsigned int arg2 ;
+ float *result = 0 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (unsigned int)jarg2;
+ {
+ try {
+ result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = *result;
+ return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
+ float jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ Dali::Vector3 *arg2 = 0 ;
+ float result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (Dali::Vector3 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ Dali::Vector3 *arg2 = 0 ;
+ Dali::Vector3 result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (Dali::Vector3 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector3((const Dali::Vector3 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
+ float jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ {
+ try {
+ result = (float)((Dali::Vector3 const *)arg1)->Length();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
+ float jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ {
+ try {
+ result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ {
+ try {
+ (arg1)->Normalize();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ Dali::Vector3 *arg2 = 0 ;
+ Dali::Vector3 *arg3 = 0 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (Dali::Vector3 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return ;
+ }
+ arg3 = (Dali::Vector3 *)jarg3;
+ if (!arg3) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return ;
+ }
+ {
+ try {
+ (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float *result = 0 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ {
+ try {
+ result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ Dali::Vector2 *result = 0 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ {
+ try {
+ result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ Dali::Vector2 *result = 0 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ {
+ try {
+ result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_x_set(void * jarg1, float jarg2) {
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->x = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_x_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ result = (float) ((arg1)->x);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_width_set(void * jarg1, float jarg2) {
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->width = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_width_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ result = (float) ((arg1)->width);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->r = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ result = (float) ((arg1)->r);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_y_set(void * jarg1, float jarg2) {
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->y = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_y_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ result = (float) ((arg1)->y);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_height_set(void * jarg1, float jarg2) {
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->height = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_height_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ result = (float) ((arg1)->height);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->g = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ result = (float) ((arg1)->g);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_z_set(void * jarg1, float jarg2) {
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->z = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_z_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ result = (float) ((arg1)->z);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_depth_set(void * jarg1, float jarg2) {
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->depth = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_depth_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ result = (float) ((arg1)->depth);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->b = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ result = (float) ((arg1)->b);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
+ Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ {
+ try {
+ delete arg1;
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = 0 ;
+ Dali::Vector3 *arg2 = 0 ;
+ Dali::Vector3 result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ arg2 = (Dali::Vector3 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector3((const Dali::Vector3 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = 0 ;
+ Dali::Vector3 *arg2 = 0 ;
+ Dali::Vector3 result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ arg2 = (Dali::Vector3 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector3((const Dali::Vector3 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = 0 ;
+ float *arg2 = 0 ;
+ float *arg3 = 0 ;
+ float temp2 ;
+ float temp3 ;
+ Dali::Vector3 result;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ temp2 = (float)jarg2;
+ arg2 = &temp2;
+ temp3 = (float)jarg3;
+ arg3 = &temp3;
+ {
+ try {
+ result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector3((const Dali::Vector3 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
+ void * jresult ;
+ Dali::Vector4 *result = 0 ;
+
+ {
+ try {
+ result = (Dali::Vector4 *)new Dali::Vector4();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
+ void * jresult ;
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ float arg4 ;
+ Dali::Vector4 *result = 0 ;
+
+ arg1 = (float)jarg1;
+ arg2 = (float)jarg2;
+ arg3 = (float)jarg3;
+ arg4 = (float)jarg4;
+ {
+ try {
+ result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
+ void * jresult ;
+ float *arg1 = (float *) 0 ;
+ Dali::Vector4 *result = 0 ;
+
+ arg1 = jarg1;
+ {
+ try {
+ result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+
+
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
+ void * jresult ;
+ Dali::Vector2 *arg1 = 0 ;
+ Dali::Vector4 *result = 0 ;
+
+ arg1 = (Dali::Vector2 *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = 0 ;
+ Dali::Vector4 *result = 0 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
+ void * jresult ;
+ Dali::Vector4 *result = 0 ;
+
+ result = (Dali::Vector4 *)&Dali::Vector4::ONE;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
+ void * jresult ;
+ Dali::Vector4 *result = 0 ;
+
+ result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
+ void * jresult ;
+ Dali::Vector4 *result = 0 ;
+
+ result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
+ void * jresult ;
+ Dali::Vector4 *result = 0 ;
+
+ result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
+ void * jresult ;
+ Dali::Vector4 *result = 0 ;
+
+ result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float *arg2 = (float *) 0 ;
+ Dali::Vector4 *result = 0 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = jarg2;
+ {
+ try {
+ result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+
+
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ Dali::Vector2 *arg2 = 0 ;
+ Dali::Vector4 *result = 0 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (Dali::Vector2 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ Dali::Vector3 *arg2 = 0 ;
+ Dali::Vector4 *result = 0 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (Dali::Vector3 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ Dali::Vector4 *arg2 = 0 ;
+ Dali::Vector4 result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (Dali::Vector4 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector4((const Dali::Vector4 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ Dali::Vector4 *arg2 = 0 ;
+ Dali::Vector4 *result = 0 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (Dali::Vector4 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ Dali::Vector4 *arg2 = 0 ;
+ Dali::Vector4 result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (Dali::Vector4 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector4((const Dali::Vector4 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ Dali::Vector4 *arg2 = 0 ;
+ Dali::Vector4 *result = 0 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (Dali::Vector4 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ Dali::Vector4 *arg2 = 0 ;
+ Dali::Vector4 result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (Dali::Vector4 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector4((const Dali::Vector4 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float arg2 ;
+ Dali::Vector4 result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (float)jarg2;
+ {
+ try {
+ result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector4((const Dali::Vector4 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ Dali::Vector4 *arg2 = 0 ;
+ Dali::Vector4 *result = 0 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (Dali::Vector4 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float arg2 ;
+ Dali::Vector4 *result = 0 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (float)jarg2;
+ {
+ try {
+ result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ Dali::Vector4 *arg2 = 0 ;
+ Dali::Vector4 result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (Dali::Vector4 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector4((const Dali::Vector4 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float arg2 ;
+ Dali::Vector4 result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (float)jarg2;
+ {
+ try {
+ result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector4((const Dali::Vector4 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ Dali::Vector4 *arg2 = 0 ;
+ Dali::Vector4 *result = 0 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (Dali::Vector4 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float arg2 ;
+ Dali::Vector4 *result = 0 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (float)jarg2;
+ {
+ try {
+ result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ Dali::Vector4 result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ {
+ try {
+ result = ((Dali::Vector4 const *)arg1)->operator -();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector4((const Dali::Vector4 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ Dali::Vector4 *arg2 = 0 ;
+ bool result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (Dali::Vector4 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ Dali::Vector4 *arg2 = 0 ;
+ bool result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (Dali::Vector4 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
+ float jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ unsigned int arg2 ;
+ float *result = 0 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (unsigned int)jarg2;
+ {
+ try {
+ result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = *result;
+ return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
+ float jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ Dali::Vector3 *arg2 = 0 ;
+ float result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (Dali::Vector3 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
+ float jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ Dali::Vector4 *arg2 = 0 ;
+ float result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (Dali::Vector4 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
+ float jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ Dali::Vector4 *arg2 = 0 ;
+ float result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (Dali::Vector4 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ Dali::Vector4 *arg2 = 0 ;
+ Dali::Vector4 result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (Dali::Vector4 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector4((const Dali::Vector4 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
+ float jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ {
+ try {
+ result = (float)((Dali::Vector4 const *)arg1)->Length();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
+ float jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ {
+ try {
+ result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ {
+ try {
+ (arg1)->Normalize();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ Dali::Vector4 *arg2 = 0 ;
+ Dali::Vector4 *arg3 = 0 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (Dali::Vector4 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return ;
+ }
+ arg3 = (Dali::Vector4 *)jarg3;
+ if (!arg3) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return ;
+ }
+ {
+ try {
+ (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float *result = 0 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ {
+ try {
+ result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_x_set(void * jarg1, float jarg2) {
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->x = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_x_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ result = (float) ((arg1)->x);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->r = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ result = (float) ((arg1)->r);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->s = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ result = (float) ((arg1)->s);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_y_set(void * jarg1, float jarg2) {
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->y = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_y_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ result = (float) ((arg1)->y);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->g = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ result = (float) ((arg1)->g);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->t = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ result = (float) ((arg1)->t);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_z_set(void * jarg1, float jarg2) {
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->z = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_z_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ result = (float) ((arg1)->z);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->b = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ result = (float) ((arg1)->b);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->p = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ result = (float) ((arg1)->p);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_w_set(void * jarg1, float jarg2) {
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->w = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_w_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ result = (float) ((arg1)->w);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->a = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ result = (float) ((arg1)->a);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->q = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
+ float jresult ;
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+ float result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ result = (float) ((arg1)->q);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
+ Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ {
+ try {
+ delete arg1;
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = 0 ;
+ Dali::Vector4 *arg2 = 0 ;
+ Dali::Vector4 result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return 0;
+ }
+ arg2 = (Dali::Vector4 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector4((const Dali::Vector4 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = 0 ;
+ Dali::Vector4 *arg2 = 0 ;
+ Dali::Vector4 result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return 0;
+ }
+ arg2 = (Dali::Vector4 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector4((const Dali::Vector4 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = 0 ;
+ float *arg2 = 0 ;
+ float *arg3 = 0 ;
+ float temp2 ;
+ float temp3 ;
+ Dali::Vector4 result;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return 0;
+ }
+ temp2 = (float)jarg2;
+ arg2 = &temp2;
+ temp3 = (float)jarg3;
+ arg3 = &temp3;
+ {
+ try {
+ result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Vector4((const Dali::Vector4 &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
+ void * jresult ;
+ Dali::Uint16Pair *result = 0 ;
+
+ {
+ try {
+ result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
+ void * jresult ;
+ uint32_t arg1 ;
+ uint32_t arg2 ;
+ Dali::Uint16Pair *result = 0 ;
+
+ arg1 = (uint32_t)jarg1;
+ arg2 = (uint32_t)jarg2;
+ {
+ try {
+ result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
+ void * jresult ;
+ Dali::Uint16Pair *arg1 = 0 ;
+ Dali::Uint16Pair *result = 0 ;
+
+ arg1 = (Dali::Uint16Pair *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
+ Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
+ uint16_t arg2 ;
+
+ arg1 = (Dali::Uint16Pair *)jarg1;
+ arg2 = (uint16_t)jarg2;
+ {
+ try {
+ (arg1)->SetWidth(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
+ unsigned short jresult ;
+ Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
+ uint16_t result;
+
+ arg1 = (Dali::Uint16Pair *)jarg1;
+ {
+ try {
+ result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
+ Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
+ uint16_t arg2 ;
+
+ arg1 = (Dali::Uint16Pair *)jarg1;
+ arg2 = (uint16_t)jarg2;
+ {
+ try {
+ (arg1)->SetHeight(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
+ unsigned short jresult ;
+ Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
+ uint16_t result;
+
+ arg1 = (Dali::Uint16Pair *)jarg1;
+ {
+ try {
+ result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
+ Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
+ uint16_t arg2 ;
+
+ arg1 = (Dali::Uint16Pair *)jarg1;
+ arg2 = (uint16_t)jarg2;
+ {
+ try {
+ (arg1)->SetX(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
+ unsigned short jresult ;
+ Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
+ uint16_t result;
+
+ arg1 = (Dali::Uint16Pair *)jarg1;
+ {
+ try {
+ result = ((Dali::Uint16Pair const *)arg1)->GetX();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
+ Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
+ uint16_t arg2 ;
+
+ arg1 = (Dali::Uint16Pair *)jarg1;
+ arg2 = (uint16_t)jarg2;
+ {
+ try {
+ (arg1)->SetY(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
+ unsigned short jresult ;
+ Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
+ uint16_t result;
+
+ arg1 = (Dali::Uint16Pair *)jarg1;
+ {
+ try {
+ result = ((Dali::Uint16Pair const *)arg1)->GetY();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
+ Dali::Uint16Pair *arg2 = 0 ;
+ Dali::Uint16Pair *result = 0 ;
+
+ arg1 = (Dali::Uint16Pair *)jarg1;
+ arg2 = (Dali::Uint16Pair *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
+ Dali::Uint16Pair *arg2 = 0 ;
+ bool result;
+
+ arg1 = (Dali::Uint16Pair *)jarg1;
+ arg2 = (Dali::Uint16Pair *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
+ Dali::Uint16Pair *arg2 = 0 ;
+ bool result;
+
+ arg1 = (Dali::Uint16Pair *)jarg1;
+ arg2 = (Dali::Uint16Pair *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
+ Dali::Uint16Pair *arg2 = 0 ;
+ bool result;
+
+ arg1 = (Dali::Uint16Pair *)jarg1;
+ arg2 = (Dali::Uint16Pair *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
+ Dali::Uint16Pair *arg2 = 0 ;
+ bool result;
+
+ arg1 = (Dali::Uint16Pair *)jarg1;
+ arg2 = (Dali::Uint16Pair *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
+ Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
+
+ arg1 = (Dali::Uint16Pair *)jarg1;
+ {
+ try {
+ delete arg1;
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
+ void * jresult ;
+ Dali::Degree *result = 0 ;
+
+ {
+ try {
+ result = (Dali::Degree *)new Dali::Degree();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
+ void * jresult ;
+ float arg1 ;
+ Dali::Degree *result = 0 ;
+
+ arg1 = (float)jarg1;
+ {
+ try {
+ result = (Dali::Degree *)new Dali::Degree(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
+ void * jresult ;
+ Dali::Radian arg1 ;
+ Dali::Radian *argp1 ;
+ Dali::Degree *result = 0 ;
+
+ argp1 = (Dali::Radian *)jarg1;
+ if (!argp1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg1 = *argp1;
+ {
+ try {
+ result = (Dali::Degree *)new Dali::Degree(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
+ Dali::Degree *arg1 = (Dali::Degree *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Degree *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->degree = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
+ float jresult ;
+ Dali::Degree *arg1 = (Dali::Degree *) 0 ;
+ float result;
+
+ arg1 = (Dali::Degree *)jarg1;
+ result = (float) ((arg1)->degree);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
+ Dali::Degree *arg1 = (Dali::Degree *) 0 ;
+
+ arg1 = (Dali::Degree *)jarg1;
+ {
+ try {
+ delete arg1;
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
+ void * jresult ;
+ Dali::Radian *result = 0 ;
+
+ result = (Dali::Radian *)&Dali::ANGLE_360;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
+ void * jresult ;
+ Dali::Radian *result = 0 ;
+
+ result = (Dali::Radian *)&Dali::ANGLE_315;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
+ void * jresult ;
+ Dali::Radian *result = 0 ;
+
+ result = (Dali::Radian *)&Dali::ANGLE_270;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
+ void * jresult ;
+ Dali::Radian *result = 0 ;
+
+ result = (Dali::Radian *)&Dali::ANGLE_225;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
+ void * jresult ;
+ Dali::Radian *result = 0 ;
+
+ result = (Dali::Radian *)&Dali::ANGLE_180;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
+ void * jresult ;
+ Dali::Radian *result = 0 ;
+
+ result = (Dali::Radian *)&Dali::ANGLE_135;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
+ void * jresult ;
+ Dali::Radian *result = 0 ;
+
+ result = (Dali::Radian *)&Dali::ANGLE_120;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
+ void * jresult ;
+ Dali::Radian *result = 0 ;
+
+ result = (Dali::Radian *)&Dali::ANGLE_90;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
+ void * jresult ;
+ Dali::Radian *result = 0 ;
+
+ result = (Dali::Radian *)&Dali::ANGLE_60;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
+ void * jresult ;
+ Dali::Radian *result = 0 ;
+
+ result = (Dali::Radian *)&Dali::ANGLE_45;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
+ void * jresult ;
+ Dali::Radian *result = 0 ;
+
+ result = (Dali::Radian *)&Dali::ANGLE_30;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
+ void * jresult ;
+ Dali::Radian *result = 0 ;
+
+ result = (Dali::Radian *)&Dali::ANGLE_0;
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Degree *arg1 = 0 ;
+ Dali::Degree *arg2 = 0 ;
+ bool result;
+
+ arg1 = (Dali::Degree *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
+ return 0;
+ }
+ arg2 = (Dali::Degree *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Degree *arg1 = 0 ;
+ Dali::Degree *arg2 = 0 ;
+ bool result;
+
+ arg1 = (Dali::Degree *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
+ return 0;
+ }
+ arg2 = (Dali::Degree *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
+ void * jresult ;
+ Dali::Degree arg1 ;
+ float arg2 ;
+ float arg3 ;
+ Dali::Degree *argp1 ;
+ Dali::Degree result;
+
+ argp1 = (Dali::Degree *)jarg1;
+ if (!argp1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
+ return 0;
+ }
+ arg1 = *argp1;
+ arg2 = (float)jarg2;
+ arg3 = (float)jarg3;
+ {
+ try {
+ result = Dali::Clamp(arg1,arg2,arg3);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Degree((const Dali::Degree &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
+ void * jresult ;
+ Dali::Radian *result = 0 ;
+
+ {
+ try {
+ result = (Dali::Radian *)new Dali::Radian();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
+ void * jresult ;
+ float arg1 ;
+ Dali::Radian *result = 0 ;
+
+ arg1 = (float)jarg1;
+ {
+ try {
+ result = (Dali::Radian *)new Dali::Radian(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
+ void * jresult ;
+ Dali::Degree arg1 ;
+ Dali::Degree *argp1 ;
+ Dali::Radian *result = 0 ;
+
+ argp1 = (Dali::Degree *)jarg1;
+ if (!argp1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
+ return 0;
+ }
+ arg1 = *argp1;
+ {
+ try {
+ result = (Dali::Radian *)new Dali::Radian(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
+ void * jresult ;
+ Dali::Radian *arg1 = (Dali::Radian *) 0 ;
+ float arg2 ;
+ Dali::Radian *result = 0 ;
+
+ arg1 = (Dali::Radian *)jarg1;
+ arg2 = (float)jarg2;
+ {
+ try {
+ result = (Dali::Radian *) &(arg1)->operator =(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Radian *arg1 = (Dali::Radian *) 0 ;
+ Dali::Degree arg2 ;
+ Dali::Degree *argp2 ;
+ Dali::Radian *result = 0 ;
+
+ arg1 = (Dali::Radian *)jarg1;
+ argp2 = (Dali::Degree *)jarg2;
+ if (!argp2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
+ return 0;
+ }
+ arg2 = *argp2;
+ {
+ try {
+ result = (Dali::Radian *) &(arg1)->operator =(arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
+ float jresult ;
+ Dali::Radian *arg1 = (Dali::Radian *) 0 ;
+ float result;
+
+ arg1 = (Dali::Radian *)jarg1;
+ {
+ try {
+ result = (float)((Dali::Radian const *)arg1)->operator float();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
+ Dali::Radian *arg1 = (Dali::Radian *) 0 ;
+ float arg2 ;
+
+ arg1 = (Dali::Radian *)jarg1;
+ arg2 = (float)jarg2;
+ if (arg1) (arg1)->radian = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
+ float jresult ;
+ Dali::Radian *arg1 = (Dali::Radian *) 0 ;
+ float result;
+
+ arg1 = (Dali::Radian *)jarg1;
+ result = (float) ((arg1)->radian);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
+ Dali::Radian *arg1 = (Dali::Radian *) 0 ;
+
+ arg1 = (Dali::Radian *)jarg1;
+ {
+ try {
+ delete arg1;
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
+ };
+ }
+ }
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Radian arg1 ;
+ Dali::Radian arg2 ;
+ Dali::Radian *argp1 ;
+ Dali::Radian *argp2 ;
+ bool result;
+
+ argp1 = (Dali::Radian *)jarg1;
+ if (!argp1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg1 = *argp1;
+ argp2 = (Dali::Radian *)jarg2;
+ if (!argp2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg2 = *argp2;
+ {
+ try {
+ result = (bool)Dali::operator ==(arg1,arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Radian arg1 ;
+ Dali::Radian arg2 ;
+ Dali::Radian *argp1 ;
+ Dali::Radian *argp2 ;
+ bool result;
+
+ argp1 = (Dali::Radian *)jarg1;
+ if (!argp1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg1 = *argp1;
+ argp2 = (Dali::Radian *)jarg2;
+ if (!argp2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg2 = *argp2;
+ {
+ try {
+ result = (bool)Dali::operator !=(arg1,arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Radian arg1 ;
+ Dali::Degree arg2 ;
+ Dali::Radian *argp1 ;
+ Dali::Degree *argp2 ;
+ bool result;
+
+ argp1 = (Dali::Radian *)jarg1;
+ if (!argp1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg1 = *argp1;
+ argp2 = (Dali::Degree *)jarg2;
+ if (!argp2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
+ return 0;
+ }
+ arg2 = *argp2;
+ {
+ try {
+ result = (bool)Dali::operator ==(arg1,arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Radian arg1 ;
+ Dali::Degree arg2 ;
+ Dali::Radian *argp1 ;
+ Dali::Degree *argp2 ;
+ bool result;
+
+ argp1 = (Dali::Radian *)jarg1;
+ if (!argp1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg1 = *argp1;
+ argp2 = (Dali::Degree *)jarg2;
+ if (!argp2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
+ return 0;
+ }
+ arg2 = *argp2;
+ {
+ try {
+ result = (bool)Dali::operator !=(arg1,arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Degree arg1 ;
+ Dali::Radian arg2 ;
+ Dali::Degree *argp1 ;
+ Dali::Radian *argp2 ;
+ bool result;
+
+ argp1 = (Dali::Degree *)jarg1;
+ if (!argp1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
+ return 0;
+ }
+ arg1 = *argp1;
+ argp2 = (Dali::Radian *)jarg2;
+ if (!argp2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg2 = *argp2;
+ {
+ try {
+ result = (bool)Dali::operator ==(arg1,arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Degree arg1 ;
+ Dali::Radian arg2 ;
+ Dali::Degree *argp1 ;
+ Dali::Radian *argp2 ;
+ bool result;
+
+ argp1 = (Dali::Degree *)jarg1;
+ if (!argp1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
+ return 0;
+ }
+ arg1 = *argp1;
+ argp2 = (Dali::Radian *)jarg2;
+ if (!argp2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg2 = *argp2;
+ {
+ try {
+ result = (bool)Dali::operator !=(arg1,arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Radian arg1 ;
+ Dali::Radian arg2 ;
+ Dali::Radian *argp1 ;
+ Dali::Radian *argp2 ;
+ bool result;
+
+ argp1 = (Dali::Radian *)jarg1;
+ if (!argp1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg1 = *argp1;
+ argp2 = (Dali::Radian *)jarg2;
+ if (!argp2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg2 = *argp2;
+ {
+ try {
+ result = (bool)Dali::operator >(arg1,arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Radian arg1 ;
+ Dali::Degree arg2 ;
+ Dali::Radian *argp1 ;
+ Dali::Degree *argp2 ;
+ bool result;
+
+ argp1 = (Dali::Radian *)jarg1;
+ if (!argp1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg1 = *argp1;
+ argp2 = (Dali::Degree *)jarg2;
+ if (!argp2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
+ return 0;
+ }
+ arg2 = *argp2;
+ {
+ try {
+ result = (bool)Dali::operator >(arg1,arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Degree arg1 ;
+ Dali::Radian arg2 ;
+ Dali::Degree *argp1 ;
+ Dali::Radian *argp2 ;
+ bool result;
+
+ argp1 = (Dali::Degree *)jarg1;
+ if (!argp1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
+ return 0;
+ }
+ arg1 = *argp1;
+ argp2 = (Dali::Radian *)jarg2;
+ if (!argp2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg2 = *argp2;
+ {
+ try {
+ result = (bool)Dali::operator >(arg1,arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Radian arg1 ;
+ Dali::Radian arg2 ;
+ Dali::Radian *argp1 ;
+ Dali::Radian *argp2 ;
+ bool result;
+
+ argp1 = (Dali::Radian *)jarg1;
+ if (!argp1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg1 = *argp1;
+ argp2 = (Dali::Radian *)jarg2;
+ if (!argp2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg2 = *argp2;
+ {
+ try {
+ result = (bool)Dali::operator <(arg1,arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Radian arg1 ;
+ Dali::Degree arg2 ;
+ Dali::Radian *argp1 ;
+ Dali::Degree *argp2 ;
+ bool result;
+
+ argp1 = (Dali::Radian *)jarg1;
+ if (!argp1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg1 = *argp1;
+ argp2 = (Dali::Degree *)jarg2;
+ if (!argp2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
+ return 0;
+ }
+ arg2 = *argp2;
+ {
+ try {
+ result = (bool)Dali::operator <(arg1,arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
+ unsigned int jresult ;
+ Dali::Degree arg1 ;
+ Dali::Radian arg2 ;
+ Dali::Degree *argp1 ;
+ Dali::Radian *argp2 ;
+ bool result;
+
+ argp1 = (Dali::Degree *)jarg1;
+ if (!argp1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
+ return 0;
+ }
+ arg1 = *argp1;
+ argp2 = (Dali::Radian *)jarg2;
+ if (!argp2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg2 = *argp2;
+ {
+ try {
+ result = (bool)Dali::operator <(arg1,arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
+ void * jresult ;
+ Dali::Radian arg1 ;
+ float arg2 ;
+ Dali::Radian *argp1 ;
+ Dali::Radian result;
+
+ argp1 = (Dali::Radian *)jarg1;
+ if (!argp1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg1 = *argp1;
+ arg2 = (float)jarg2;
+ {
+ try {
+ result = Dali::operator *(arg1,arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Radian((const Dali::Radian &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
+ void * jresult ;
+ Dali::Radian arg1 ;
+ Dali::Radian *argp1 ;
+ Dali::Radian result;
+
+ argp1 = (Dali::Radian *)jarg1;
+ if (!argp1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg1 = *argp1;
+ {
+ try {
+ result = Dali::operator -(arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Radian((const Dali::Radian &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
+ void * jresult ;
+ Dali::Radian arg1 ;
+ float arg2 ;
+ float arg3 ;
+ Dali::Radian *argp1 ;
+ Dali::Radian result;
+
+ argp1 = (Dali::Radian *)jarg1;
+ if (!argp1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg1 = *argp1;
+ arg2 = (float)jarg2;
+ arg3 = (float)jarg3;
+ {
+ try {
+ result = Dali::Clamp(arg1,arg2,arg3);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = new Dali::Radian((const Dali::Radian &)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Quaternion__SWIG_0() {
+ void * jresult ;
+ Dali::Quaternion *result = 0 ;
+
+ {
+ try {
+ result = (Dali::Quaternion *)new Dali::Quaternion();
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Quaternion__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
+ void * jresult ;
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ float arg4 ;
+ Dali::Quaternion *result = 0 ;
+
+ arg1 = (float)jarg1;
+ arg2 = (float)jarg2;
+ arg3 = (float)jarg3;
+ arg4 = (float)jarg4;
+ {
+ try {
+ result = (Dali::Quaternion *)new Dali::Quaternion(arg1,arg2,arg3,arg4);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Quaternion__SWIG_2(void * jarg1) {
+ void * jresult ;
+ Dali::Vector4 *arg1 = 0 ;
+ Dali::Quaternion *result = 0 ;
+
+ arg1 = (Dali::Vector4 *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Quaternion *)new Dali::Quaternion((Dali::Vector4 const &)*arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Quaternion__SWIG_3(void * jarg1, void * jarg2) {
+ void * jresult ;
+ Dali::Radian arg1 ;
+ Dali::Vector3 *arg2 = 0 ;
+ Dali::Radian *argp1 ;
+ Dali::Quaternion *result = 0 ;
+
+ argp1 = (Dali::Radian *)jarg1;
+ if (!argp1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg1 = *argp1;
+ arg2 = (Dali::Vector3 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Quaternion__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
+ void * jresult ;
+ Dali::Radian arg1 ;
+ Dali::Radian arg2 ;
+ Dali::Radian arg3 ;
+ Dali::Radian *argp1 ;
+ Dali::Radian *argp2 ;
+ Dali::Radian *argp3 ;
+ Dali::Quaternion *result = 0 ;
+
+ argp1 = (Dali::Radian *)jarg1;
+ if (!argp1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg1 = *argp1;
+ argp2 = (Dali::Radian *)jarg2;
+ if (!argp2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg2 = *argp2;
+ argp3 = (Dali::Radian *)jarg3;
+ if (!argp3) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
+ return 0;
+ }
+ arg3 = *argp3;
+ {
+ try {
+ result = (Dali::Quaternion *)new Dali::Quaternion(arg1,arg2,arg3);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Quaternion__SWIG_5(void * jarg1) {
+ void * jresult ;
+ Dali::Matrix *arg1 = 0 ;
+ Dali::Quaternion *result = 0 ;
+
+ arg1 = (Dali::Matrix *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result = (Dali::Quaternion *)new Dali::Quaternion((Dali::Matrix const &)*arg1);
+ } catch (std::out_of_range& e) {
+ {
+ SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (std::exception& e) {
+ {
+ SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+ };
+ } catch (...) {
+ {
+ SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+ };
+ }
+ }
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Quaternion__SWIG_6(void * jarg1, void * jarg2, void * jarg3) {
+ void * jresult ;
+ Dali::Vector3 *arg1 = 0 ;
+ Dali::Vector3 *arg2 = 0 ;
+ Dali::Vector3 *arg3 = 0 ;
+ Dali::Quaternion *result = 0 ;
+
+ arg1 = (Dali::Vector3 *)jarg1;
+ if (!arg1) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ arg2 = (Dali::Vector3 *)jarg2;
+ if (!arg2) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ arg3 = (Dali::Vector3 *)jarg3;
+ if (!arg3) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+ return 0;
+ }
+ {
+ try {
+ result =&nb
projects / platform / core / uifw / dali-toolkit.git / commitdiff